In this getting started tutorial, learn how to get started creating powerful reports with Telerik Reporting and ASP.NET Core.

Do you remember Getting Started with Telerik Reporting and ASP.NET 5? Times have changed, and now we all have ASP.NET Core, it’s supported in our products and we’ve even made new developer toolsjust for it. There is no more MVC6 and ASP.NET5.

Yes, names changed a lot and we have followed suit. Let’s talk about getting started with Telerik Reporting and ASP.NET Core.

To get started with ASP.NET Core we recommend reviewing the official Microsoft documentation available at Introduction to ASP.NET Core (docs.microsoft.com), and the mandatory downloads to prepare your development environment:

• Visual Studio 2015 Update 3
• NET Core 1.0.1 - VS 2015 Tooling Preview 2

Once the machine is ready, we can go on with the settings:

Creating a Sample ASP.NET Core Project

1. Open Visual Studio 2015 Update 3
2. From the File menu, select New > Project
3. In the New Project dialog, expand Installed > Templates > Visual C# > Web, and select ASP.NET Core Web Application (.NET Framework) project template. Choose a name for the project and click OK.
4. From the ASP.NET Core Templates select Web Application

Visual Basic templates for ASP.NET Core are not available. Please pay a special attention to the type of project we are initiating.

Getting Ready to Add Telerik Reporting

You will have to prepare the project for Telerik Reporting.
Open the project.json file. The "frameworks" property should look like this:

"frameworks": {    "net461": { }},

The above setting is required since the Telerik Reporting engine needs the full .NET framework. Note, that using multiple target frameworks will force Visual Studio to build your project as if it will run on all frameworks, and ultimately you will not be able to start it.

We are going to add the Reporting REST service in the same project, which means the Reporting engine will be there and it requires a Windows OS machine with .NET 4 Framework or greater.

Adding the NuGet Packages

ASP.NET Core does not support references to assemblies, but instead works with references to NuGet packages. To setup the Reporting REST service you have to reference the latest Telerik.Reporting.nupkg and Telerik.Reporting.Services.AspNetCore.nupkg NuGet packages from the private Telerik NuGet feed. You can learn how to add a NuGet feed here.

You will need your Telerik account credentials for this operation.

Setting up the REST Service

1. In your project, right-click References, choose Manage NuGet Packages and from the Package source drop-down menu, select Telerik private feed
2. Install Telerik.Reporting and Telerik.Reporting.Services.AspNetCore NuGet packages, which is necessary for the Telerik Reporting REST Service and the Reporting engine
3. Once the packages are referenced, you have to implement a Reports controller. Right-click on the Controllers folder and add a new item: Add > New item > Installed > ASP.NET > Web API Controller Class item. Name it ReportsController. This will be our Telerik Reporting REST service in the project.
4. It will have to inherit the ReportsControllerBase type from the NuGet package and provide proper settings for the service's ReportResolver and Storage. This is how a basic implementation of the controller should look:
   
   
   C#

   namespaceWebApplication1.Controllers

   {

       usingSystem.IO;

       usingMicrosoft.AspNetCore.Hosting;

       usingTelerik.Reporting.Cache.File;

       usingTelerik.Reporting.Services;

       usingTelerik.Reporting.Services.AspNetCore;

    

       publicclassReportsController : ReportsControllerBase

       {              

           publicReportsController(IHostingEnvironment environment)

           {

               var reportsPath =

                  Path.Combine(environment.WebRootPath, "Reports");

    

               this.ReportServiceConfiguration =

                  newReportServiceConfiguration

                   {

                       HostAppId = "Html5DemoApp",

                       Storage = newFileStorage(),

                       ReportResolver = newReportFileResolver(reportsPath),

                       // ReportSharingTimeout = 0,

                       // ClientSessionTimeout = 15,

                   };

            }

       }

   }
   
   
   
5. After the Reports controller is setup, you have to create an MVC page view with the HTML5 report viewer. To do so, open the HomeController, added by the VS ASP.NET Core project template, and add an action method named Report:
   
   
   C#

   publicIActionResult Report()

   {

       ViewBag.Message = "Your reports page.";

       returnView();

   }

Adding the HTML5 Report Viewer

1. To set up a folder for the reports, right-click on wwwroot and select Add > New Folder. Name the folder Reports and add sample reports in TRDP format for easiness. You can find sample reports in {Telerik Reporting installation path}\Report Designer\Examples if you have an existing installation of the Telerik Reporting product.
   
   Note that the name of the folder is considered with the folder path used by the ReportFileResolver in the ReportsController.
   
   This tutorial will use Barcodes Report.trdp in all examples.
2. Add a view that contains the HTML5 Report Viewer.
   
   Open the Views folder, right-click on the Home folder and select Add > New Item > Installed > ASP.NET. Then add a new MVC View Page named Report. We want the Report action in the HomeController to target this view.
   
   Add the HTML5 Report Viewer. For a detailed explanation, check the HTML5 Report Viewer Manual Setup help article in the online documentation.
   
   The required references to jQuery and Telerik Kendo UI CSS and JS files are listed in the example below. Copy the Kendo UI subset from {Telerik Reporting installation path}\Html5\ReportViewer folder to wwwroot.
   
   Important:
   Whenever you need to route a relative path you will have to use Url.Content helper, like this:
   
   

   Html@Url.Content("~/api/reports/")

   
   instead of simply pasting the path.
   
   The complete Report view (Report.cshtml) should look like this:
   
   @{

       Layout = null;

   }

   <!DOCTYPE html>

   <html>

   <head>

       <title>APS.NET Core HTML5 Report Viewer Demo</title>

    

       <metacharset="utf-8"/>

       <metahttp-equiv="X-UA-Compatible"content="IE=edge"/>

       <metaname="viewport"content="width=device-width, initial-scale=1, maximum-scale=1"/>

    

       <scriptsrc="https://code.jquery.com/jquery-2.2.4.min.js"integrity="sha256-BbhdlvQf/xTY9gja0Dq3HiwQF8LaCRTXxZKRutelT44="crossorigin="anonymous"></script>

    

       <linkhref="http://kendo.cdn.telerik.com/2015.3.930/styles/kendo.common.min.css"rel="stylesheet"/>

       <linkhref="http://kendo.cdn.telerik.com/2015.3.930/styles/kendo.blueopal.min.css"rel="stylesheet"/>

    

       <!-- the required Kendo subset is located in {Telerik Reporting installation path}\Html5\ReportViewer\js --> 

       <scriptsrc="/ReportViewer/js/telerikReportViewer.kendo-x.x.x.x.min.js"></script>

    

       <!--If Kendo CDN is prefered here are the required Kendo widgets and bundles

    

       The minimum required widgets:

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.core.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.data.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.tooltip.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.calendar.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.datepicker.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.listview.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.menu.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.panelbar.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.treeview.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.popup.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.userevents.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.selectable.min.js"></script>

       <scriptsrc="http://kendo.cdn.telerik.com/2015.3.930/js/kendo.touch.min.js"></script>

    

       Widgets bundle:

       kendo.all.min.js can be used instead of the above widget list

       -->

    

       <scriptsrc="/api/reports/resources/js/telerikReportViewer-10.2.16.1025.min.js"></script>

    

       <style>

           #reportViewer1 {

               position: absolute;

               left: 5px;

               right: 5px;

               top: 5px;

               bottom: 5px;

               overflow: hidden;

               font-family: Verdana, Arial;

           }

       </style>

   </head>

    

   <body>

       <divid="reportViewer1">

           loading...

       </div>

    

       <scripttype="text/javascript">

           $(document).ready(function () {

               $("#reportViewer1")

                   .telerik_ReportViewer({

                       // The URL of the service which will serve reports.

                       // The URL corresponds to the name of the controller class (ReportsController).

                       // For more information on how to configure the service please check http://www.telerik.com/help/reporting/telerik-reporting-rest-conception.html.

                       serviceUrl: '@Url.Content("~/api/reports/")',

    

                       // The URL for the report viewer template. The template can be edited -

                       // new functionalities can be added and unneeded ones can be removed.

                       // For more information please check http://www.telerik.com/help/reporting/html5-report-viewer-templates.html.

                       @*templateUrl: '@Url.Content("~/ReportViewer/templates/telerikReportViewerTemplate-FA.html")',*@

    

                       //ReportSource - report description

                       reportSource: {

    

                           // The report can be set to a report file name

                           // or CLR type name (report class definition).

                           report: "Barcodes Report.trdp",

    

                           // Parameters name value dictionary

                           parameters: {}

                       },

    

                       // Specifies whether the viewer is in interactive or print preview mode.

                       // PRINT_PREVIEW - Displays the paginated report as if it is printed on paper. Interactivity is not enabled.

                       // INTERACTIVE - Displays the report in its original width and height without paging. Additionally interactivity is enabled.

                       viewMode: telerikReportViewer.ViewModes.INTERACTIVE,

    

                       // Sets the scale mode of the viewer.

                       // Three modes exist currently:

                       // FIT_PAGE - The whole report will fit on the page (will zoom in or out), regardless of its width and height.

                       // FIT_PAGE_WIDTH - The report will be zoomed in or out so that the width of the screen and the width of the report match.

                       // SPECIFIC - Uses the scale to zoom in and out the report.

                       scaleMode: telerikReportViewer.ScaleModes.SPECIFIC,

    

                       // Zoom in and out the report using the scale

                       // 1.0 is equal to 100%, i.e. the original size of the report

                       scale: 1.0,

                   });

           });

       </script>

   </body>

   </html>
   
   The reference to the report viewer's JavaScript file (telerikReportViewer-x.x.x.x.min.js) should be updated to the corresponding version of the Reporting NuGet package.
3. To add a link to the Report view in the Home page navigation open Views\Shared\_Layout.cshtml page and add:
   

   Html   

   <li><a asp-area="" asp-controller="Home" asp-action="Report">Report</a></li>

   list item to the navigation. It should become like this:

   Html

    

   <li><aasp-area=""asp-controller="Home"asp-action="Index">Home</a></li>

    

   <li><aasp-area=""asp-controller="Home"asp-action="About">About</a></li>

    

   <li><aasp-area=""asp-controller="Home"asp-action="Contact">Contact</a></li>

    

   <li><aasp-area=""asp-controller="Home"asp-action="Report">Report</a></li>

Connection Strings and Engine Configuration

Telerik Reporting relies on the ConfigurationManager to resolve named connection strings and to configure the reporting engine. Thus if you have any named connectionstrings in your reports or you need to configure Telerik Reporting you have to add app.config configuration file to the project's root. For more information see: Telerik Reporting Configuration Section.

For example:

Finally, run the project and navigate to the Report view to see the report.

What You Should Know about Telerik Reporting in ASP.NET Core Projects

What we did with Telerik Reporting is to allow previewing Telerik Reports. The processing and rendering mechanisms are bound to Windows OS and its GDI+ API. The good news is that for some years now we have been working on separating preview from document generation.

This means you can host the Reporting REST Service separately on a Windows server and let your HTML5 Viewer run freely in any other environment you have to support.

Try Reporting Out Today

Ready to give Telerik Reporting a try? You can learn more here or download a free trial at the link below. We always appreciate your feedback (the real world voice) to help us keep making things better.

Try Reporting Now

Steve McNiven-Scott, known as Sitefinity Steve, is also an expert with a vast array of other Telerik products.

This post is part of a series featuring our Developer Experts, community members who represent the best of our products. Read about our other featured experts here and meet more DEs here.

What’s your background, professionally?

I always loved to code; I was the kid who stayed in at recess to rip some QBasic games on the epic Unisys trackball computers. My first programming job, though, was at General Motors using VB6 to control GE Cimplicity; that was about as painful as it gets. Luckily I was able to transfer over to a university and start working with modern languages and development stacks.  

Where are you based and why?

I'm in picturesque Hamilton, Ontario, Canada!

With whom are you working?

I work with a small team locally called Firescript, my colleague Ryan is a great designer and developer. I'm doing external work though my personal company.

What project are you working on now?

I'm working on a children's word finding game using NativeScript. My son's school sent home a boring list of words to practise, and I figured it would be more fun to create something interactive with him. I'm also working on a secret NativeScript app and various Sitefinity sites and a couple of small portfolio .NET Core sites like this.

What’s the most interesting project you’ve done recently?

I've found that making a game on NativeScript is very different beast than a simple business app. It requires lots of playing around with Sketch and Illustrator to create image resources; everything is an image. But then turning it around and having your 5 year old play it is very satisfying.

Which of our products do you use and why?

• NativeScript: It's unreal how complex an app you can create with very little code, and you can’t beat the price!  
• Kendo UI: For all your JavaScript widget needs, trimmed down with custom builds.
• Sitefinity: A fantastic CMS built on ASP.net, MVC, webforms, or both combined.  The current focus on the front end with Angular\Bootstrap is just great.
• JustCode: For lots of great VS IDE features
• JustDecompile: A great profiling tool to track down bottlenecks.
• Test Studio: Allows us to test the complex Sitefinity frontend pages and widgets UI elements to make sure we’re not breaking anything.
• Reporting: Admins need printable reports! The great thing about these is you can create coded reports, not just ones bindable to SQL.
• Data Access: Powers Sitefinity, however we have a couple of custom external databases fluently mapped with it; it's available free on Nuget.
• JustTrace: Helps us find performance bottlenecks on our site.

What are some challenges you are encountering now in your work?

It's challenging to stay on top of new frameworks and trends. It’s hard needing to be mostly in Windows, but all the good CLI stuff is a reboot away into OSX. Realize I can do most on Windows, but on a MacBook you lose a lot of the handy touchpad gestures; just a nicer terminal experience.

What’s the biggest software pain point, in your opinion, in the mind of your partners/clients?

Authentication! It's really hard to manage all the logins that go into an app or site, such as Mailgun, Analytics, Apple developer, Google Play, Telerik\Progress, Mailchimp, Domain, Zendesk, and Hosting\Server logins.

To create the most efficient work environment, you need to standardize on tools and processes in a way that makes sense. Read on for tips on what works best.

In a whitepaper I wrote recently, I talked about two hypothetical organizations. I used them to offer a study in hyperbolic contrast.

The first had a team of five developers, none of whom used the same development practices. In fact, one of whom used a completely different programming language. They tracked defects using email, and they operated less as a group and more as a collection of ships passing in the night. If a customer issue arose in the code of a person on vacation, well, then that customer just had to wait.

On the other side of the aisle sat a massive enterprise. Here, the team not only used the same programming language, but the same everything. Rather than leave this to chance, the organization restricted access to the machines so that developers couldn't install anything of their choosing. Instead of leaving things to chance, an architectural center of excellence controlled design decisions. And any deviation from any practice required forms in triplicate.

I used this hyperbole to draw contrast between teams that could benefit from standardization and teams crippled by it. Predictably, scale plays an important role in the distinction. To scale an enterprise, one must standardize some operational concerns. But in doing so, it risks choking the life out of individual innovation.

How can you standardize while minimizing bureaucracy? Today, I'd like to offer some tips for striking the balance.

Get Buy-In

In my travels as a consultant, I've seen no quicker path to nonsense than tone-deaf edicts from on high. Upper management decides to mandate 75% unit test coverage, and suddenly tests with no assertions and no value appear like mushrooms after a rain. An important architect decides that all methods should have comments, and suddenly "//This is a comment" adorns every method in the codebase. You get the idea.

When you force practices on intelligent people like software developers, you most likely won't enjoy the results. Instead, seek to enlist them and get them to believe in the standard.

Now you may have some team members that agree and others that disagree, depending on the standard. But having any that agree will help with adoption. This holds doubly true if the minority faction at least feels that people have heard its voice. If the standards come from the team, instead of rolling down on top of them, you'll have more success.

Create a Pit of Success

Speaking of success, you should create what I'll call a "pit of success" for following the standards. I can't claim credit for this term. It evolved to describe a situation where someone has the easiest time doing "the right thing." For example, imagine visiting a how to website and finding yourself confronted with a big, fat "start by clicking this button" button in the middle of the page. You will probably get this right.

Apply this sort of thinking to the standards that you create. If people have to work hard and remember details, they'll mess up. When this happens, enforcing the standard becomes a matter of nagging and punishing.

Instead, seek to remove thinking from the equation. For cosmetic coding standards, invest in tools that automatically "clean up" the code. With unit test coverage, fail builds or deny check-ins on insufficient coverage. Make information related to standards easily accessible, big, and visible. Make it hard or impossible to fail.

Automate as Much as Possible

Did you notice something about the "pit of success" examples that I called out? Use a tool to modify code cosmetically and use the build or gatekeeper to bounce untested code. In both cases, automation answers the call.

Automation represents a specific instance of the "pit of success," but I believe it worth calling out separately. As software development shops, we trade in automation, but frequently fail to apply it to our own processes. We should fix that. Automation reduces effort and presents mistakes.

Standards create potential friction in a few ways. Compliance can prove burdensome and annoying, and the pit of success addresses that. But they can also cause bickering over compliance, reducing morale. Automation frequently addresses this concern. If nothing else, it displaces anger from a teammate to a tool. Better to have your team despise "the stupid net nanny" than a line manager constantly snooping on their internet browsing activity.

Articulate the Why

Switching gears a bit, consider a more philosophical approach. You should always be able to articulate the "why" about a standard. In fact, so should everyone to whom it applies.

At the most basic level, this curtails the perception of arbitrary nitpicking over rules. While team members may not agree with the reason for adopting a particular standard, at least they have a reason. Without that, morale plummets as team members perceive bureaucracy for its own sake.

But articulation of why serves an even more important purpose. It creates a self-policing guard against obsolete or pointless standardization. A culture that continually asks "why" sets itself up to cut bait when no one knows why. Follow this piece of advice and you'll have a natural mechanism to retire standards that have outlived their usefulness so that you can focus on meaningful ones.

Standardize on Things that Please

The last tip that I'll offer may seem a bit optimistic, but please bear with me. You have a staggering array of things on which you could standardize, so try to choose ones that make life easier or better for the dev team.

I'll get more concrete so that you understand what I mean. Standardizing on a single source control tool simply makes sense to the point of being a no-brainer. But you have a good bit of discretion in which system you pick.

I have seen source control tools whose existence can only be explained by frequent, expensive golf outings between a sales rep and a CIO. Nobody that actually has to use these abominations would ever have picked them, and yet they become standard. Don't do this, no matter who buys you a round of golf. Standardize around things that make the team members' lives easier and that make them happy.

Obviously, not everyone will agree about every tool all of the time. But you'll get a lot further if you standardize on things with enthusiastic supporters.

Parting Advice

You'll notice that all of this advice centers around involving the people asked to comply with the standards. That's no accident. Standards apply to all of the people doing the work, so bringing them into the decision-making makes success much more likely.

In that vein, consider one last thing. You hire intelligent people because you trust them to get their work done and to make good decisions. But each standard you create and enforce takes a decision out of their hands. So do that as infrequently as you can. Err on the side of letting people exercise good judgement by only creating standards when they prove absolutely necessary.

To learn more about the advantages and disadvantages of standardization as well as to get tips on what, when and how to standardize for maximum result and minimum pain, check out the recent whitepaper I wrote: Striking the Development Standardization Balance: Key Considerations.

Curious about our plans for Kendo UI for React? Read on for our update about the future of the suite.

Let's start with the great news. Thanks to the feedback received from you, we decided to resume the work on React UI suite, also known as Kendo UI for React. We recognize the platform as a prominent force that will shape web development in the near future. ThoughtWorks puts it in the "adopt" quadrant. We love it.

"I believe React is the new jQuery."

Burke Holland, DevRel, @ProgressSW

You seem to like it, too. Our blog post from last October, Kendo UI for React—The Road Ahead, spurred a healthy discussion in the comments, plus some additional insights in my mailbox. Enough waiting, it’s time we get a move on!  

Lessons We Learned from Angular

Kendo UI supports AngularJS 1.x through directives that wrap our jQuery widgets.

For Kendo UI for Angular 2, we started fresh with a pure implementation based entirely on the framework concepts.

#1 - The Wrappers Approach is a Compromise

While good enough for many, the Kendo UI AngularJS 1.x wrappers have to co-exist with our existing two-way binding implementation and data binding abstractions, and sometimes you just had to reach out to jQuery for certain scenarios.

Some of you welcomed that. Kendo UI was your known companion as you explored the unknowns of the AngularJS framework. As projects grew and matured, many recognized the wrappers approach as a bottleneck, an impediment and a foreign citizen. At times, we could not keep up with the breaking changes introduced in the releases. Many of you were not happy with the insufficient amount of Angular-specific help topics and code samples.

The wrappers approach is not the first-class toolkit a major web framework deserves. They can be "good enough," on time and still bring a lot of value. But they won't bring the raving fans. Ultimately, will the very developers pushing React ever stand behind a wrapper approach?

#2 - The Pure Approach Feels Great, but Takes Time

Our Angular 2 UI suite does not suffer from the limitations and gotchas of the wrappers approach. It supports the platform features properly (at times being the only UI suite that does it) and it will automatically pick up any underlying performance improvements.

Ultimately, it's not just about getting a quick solution out there. Instead, we want to get everything right and deliver something that all React developers will want to use. Unfortunately, this presents a key downside: this approach ends up taking longer to deliver the final product.

"Thanks for answering. The problem is that my customer doesn't want to wait till you release Scheduler."

- Reply from a forum thread about the Scheduler for Angular 2 availability

Verdict: Wrappers vs. Pure

We can safely say that both the wrappers and the pure approach have their pros and cons. But which one should we pick for React?

Well, why not? The wrappers may be the short-term solution that can help you with something until the real thing becomes available.

The biggest challenge with the dual approach is the lack of compatibility between the wrappers and the pure implementation. How much is the migration going to hurt? We don't know yet, but we don't see a point in making the pure implementation backwards compatible with the wrappers—this means backporting things that don't look right in the platform context.

Despite the challenge, doing both wrappers and pure implementation seems like the best thing we can do for you. Support for wrappers as a short-term solution while at the same time working on the pure implementation as the recommended, long-term solution.

While our engineering team is busy dusting off the Babel Webpack setup, let's talk. The feedback we received previously was very positive and helpful; it helped us to really understand where the platform fits in your priorities. Please help us again by letting us know how your React adoption going. What do you need right now? Do you need more help with some short term wrapper solution or guidance on how to use the jQuery widgets in React?

Take a few minutes to fill out our survey—you could help us shape the future of Kendo UI for React!

Building applications often feels like an epic quest, with devious dragons and perilous pitfalls waiting around every corner.     

The recently released 2017 Stack Overflow Developer Survey unearthed a ton of intriguing information about the developer community. The Kendo UI team, influenced by the heroic origins of our JavaScript UI library’s brand name, saw these results through our own prism: all evidence suggests that being a developer is like being the brave hero on a daring quest!

Developers need to work fast, yet quality should not be compromised either. Your work provides a backbone for multiple industries or vertically supports other teams inside your organization, so it is highly visible. You need to learn quickly and efficiently as ecosystems keep changing while tools and methodologies multiply.

We approached our designers with this idea and they created an infographic illustrating the quest—and how we join forces to slay the dragon:

The compromise between speed and quality is a fact of life for all professions and developers seem to be making their peace with it. As per the Stack Overflow survey, 60.2% of developers agree (to a lesser or higher degree) with the statement “Ship It! (We Can Optimize Later).” They must be familiar with the deadline dragon.

Still, a beautiful end result and stakeholder satisfaction remains a focus. In a survey of 181 Kendo UI customers we conducted a few months ago, 47% of respondents said creating a sleek UI is their main challenge when building JavaScript and HTML5 apps. Among the top three challenges, you’ll also find designing the app architecture (second) and building responsive apps for multiple devices and collecting all requirements (sharing the third place).

As for the trade-off between quality and speed, there are some things you can do to boost both: find a good partner. There are many reasons to choose Kendo UI and our developer community is among the most convincing ones. Of developers surveyed, 72% agree that customers and other stakeholders react positively to UI created with Kendo UI.

Not familiar with our UI tooling yet? Don’t worry, 62% of our customers were writing production-ready code with Kendo UI within a week. Now is as good a time as ever to start.

Try Kendo UI

Infographic design by Rositsa Raleva.

Choosing the right technology for your desktop application project can be hard. We've created a short questionnaire to help you make an informed decision.

The Developer Dilemma

However, these results might exclude the project requirements and there are quite a few factors to be considered before drawing the line.

Making a Choice

• What environment or OS are you targeting?
• How important is ease of development and the memory footprint?
• What is your budget for the project and what are the deadlines for production?
• How crucial is the stability of the applications?
• What development language do you and your team specialize in and feel comfortable with?

Additionally, developers have to consider factors such as framework sustainability and long term usability, the ease of setting up a build-environment to ensure an easy hand-off to other people maintaining the app, as well as documentation to help your developers get started. 

In order to make the right decision, you first need to answer these questions for yourself and assess the possible options based on them. This topic is pretty massive and there is no one size fits all solution. Not only that, but as we are embracing the mobile-first mindset, you have to think about extending your desktop app experience towards other device families, such as phones or tablets.

Choosing the RIGHT Technology for Your Next .NET Desktop Application 

Here at Progress, we have a long history with the .NET stack and the various technologies and frameworks revolving around it. Our mission has always been to empower developers and provide them with the right tools, whether UI or productivity, to enable faster and more robust application development. With that in mind, we felt the need to step in and help you solve the challenges you face in your day to day tasks. 

We've created a short questionnaire to guide you in the right technology of choice for your next .NET desktop application. The questions are aimed at narrowing down the options and providing the best solution for your case. Based on your answers, we will suggest the best match of technology for you, backed up by a detailed overview, a comparison with alternative options and resources to kick-start your development. 

Take me to the Questionnaire

Next Steps 

We hope you find this survey useful—please feel free to reach out and let us know what you think in the comment section below! 

Made up your mind on your go-to technology? Make sure to try out one of our UI toolkits. We offer support for every .NET tech:

• UI for WinForms
• UI for WPF
• UI for UWP
• UI for Xamarin
• Kendo UI(Electron)
• UI for NativeScript (JavaScript)

Happy coding!

This post is part of a series featuring our Developer Experts—community members who represent the best of our products. Feel free to read about our other featured experts and meet more DEs.

Josh Eastburn and Jonathan "J" Tower, Developer Experts who work together at Trailhead Technology Partners, talk about cool hologram projects, staying up to date, and "reading the future" for clients.


Josh Eastburn and Jonathan "J" Tower from Trailhead Technology Partners

What are your backgrounds, professionally?

Jonathan: I've worked at several different companies over the years, mostly as a software consultant. For the last year-and-a-half, I've been running my own custom software shop called Trailhead Technology Partners.

Josh: I started working in my dad’s greenhouse business at the age of 8, but after I got my first computer (a Micron 386 with Windows 3.1 in 1992), I knew I wanted to work in technology. I’ve been doing custom software development for almost 20 years, starting with my first internship at a greenhouse ERP software company based in Grand Rapids, Michigan (that used Progress Database!) Since then I’ve worked for both software consulting companies and as a part of internal corporate development teams. I joined Trailhead Technology Partners as a partner in 2016 and have loved every moment of it.

Where are you based and why?

Jonathan: I live in Grand Rapids, Michigan. I love it here because of the culture, creativity, and fantastic technology community. It's also the biggest little city I've ever seen, offering all the amenities—fantastic food, beer, and entertainment options—that you'd expect in a larger metropolitan area, but without all the traffic.

Josh: I started my career working in Chicago, but when our daughter was born, she cried enough to convince us to move closer to family. We now live near Charlotte, North Carolina where we exchanged blustery winters for boiling summers, but we really enjoy it here.

With whom are you working?

Jonathan and Josh: We both work for Trailhead Technologies. We have partnerships with Progress and Xamarin. Our current clients and projects are in several industries including insurance, finance, auto repair, and real estate.

What projects are you working on now?

Jonathan: We're doing a lot of cool enterprise projects using a combination of ASP.NET Core, Angular2, Xamarin, and of course, Kendo UI.

Josh: I have two projects I’m working on right now: one is a Windows 10 UWP app and the other is a Xamarin mobile app and ASP.NET MVC / Web API for estimating and invoicing auto body repairs.

What’s the most interesting project you’ve done recently?

Jonathan: I'm working with a client on a consumer credit score application that allows users to sign up and track their credit history and improve their score. It's an interesting set of problems to solve, and fun to do it using all the coolest and newest technologies!

Josh: One of my current projects is one of the most interesting I’ve worked on in a while. It is a Windows 10 UWP app with a holographic display and an integrated Unity player for displaying and rotating 3D models. The app uses heavily customized and styled Telerik UI for UWP controls and calls an ASP.NET Core Web API that is hosted in Azure along with database, blob storage, and CDN. It will have an Angular 4 with Kendo UI for Angular admin interface. It is a rare thing to be working on a project that brings about amazement when I demo it, even to non-tech people!

Which of our products do you use and why?

Jonathan: Though we use several members of the DevCraft family, our most commonly-used Progress product is Kendo UI. We love having a set of rich UI components that work well with modern JavaScript frameworks like Angular 2 and 4. Many Angular projects piece together many UI components that all work differently. When we use Kendo, we have one consistent set of tools that we love.

Josh: We use Progress products on a lot of our projects and it varies depending on the project technology and requirements. Right now we have a project using UI for UWP and several using Kendo UI. We are starting on some projects that will use Kendo UI for Angular. Using DevCraft tools definitely speeds up our development time since we don’t have to build everything from scratch.

What are some challenges you are encountering now in your work?

Jonathan: Time management! Owning a company is hard work. Besides doing some of the hand-on work for the projects, I'm always trying to think about strategy, what's next, and trying to sure everyone has what they need to keep moving forward.

Josh: An ongoing challenge is managing tasks for multiple projects and keeping up the level of communication with clients that we strive for. Having the right tools certainly helps and we typically use Visual Studio Team Services for work item management and Slack for team communication.

From your experience, what’s the biggest software pain point in the mind of your partners/clients?

Jonathan: Our clients often look to us to help them decide if and when to move to new technologies. No one wants to launch an application built on an already-dead technology, and so attempting to read the future is a way we often try to help our clients.

Josh: As we know, technology is always changing and that is part of life for developers. However, I often see clients struggle with the decision when presented with the option of building a large-scale application using last year’s stable, mature technology or this year’s new technology. We help them walk through it and make the best choice for their project, but building a large application on the latest technology is not without challenges and risk. The choices we see this year are full .NET Framework vs. .NET Core and Kendo UI vs. Kendo UI for Angular. It would be great to always choose the latest technology, but there are trade-offs, like the more limited set of functionality for Kendo Angular. But we know that patience here will pay off.

The Kendo UI for Angular final release has landed! Angular 4, Grid improvements, a date picker and more new features await. Learn more in a Webinar May 9th.

We're excited to announce that Kendo UI for Angular has officially arrived! Let's mention the important things first—the packages are compatible with Angular 4. If you're wondering if you should switch to Angular 4—do it. Angular 2 is a short-lived version, while Angular 4 promises long-term support (18 months sound like eons of internet time). If you are not ready to make the switch to Angular 4, then you should use the @ng2 dist tag (GitHub Issue ↗). More information about dist tags is available in the NPM docs. 

If you've been watching the Kendo UI for Angular website, including our release history, the above may not be news to you. The release announcements we publish are more of a reflection and a sum-up of the new things that have been published since the last release. The ultimate place to find changes for each package is on the respective Changelog page—some popular ones being the Grid, the Dropdowns, and the DateInputs packages.

The support of Angular 4 also affected the name of the product (we have been changing this silently for a while). We refer to it as simply Kendo UI for Angular. To avoid confusion with the pre-2 era, we usually refer to our jQuery AngularJS 1.x wrapper directives as AngularJS 1.x.

The Grid Component—Version Next

Based on your feedback, the Grid component has been our number one priority for the period. The interactive live demos and the documentation speak better than any screenshots:

• Inline editing through reactive forms
• Filtering through a filter row
• Export to PDF
• Export to Excel

DatePicker is Here!

Choosing the correct date conveniently when filling a form is hard. Based on the feedback we got from you, We decided to step up our game. We have introduced a new Calendar UI with scrolling based movement through months and years, which is a change when compared to the "classic" UI from before. 

This is only a part of the story, though. The biggest change (and the one I am personally a fan of) is the introduction of the date input component, which introduces a masked input that facilitates fast and error-free date entry through the keyboard. The power users of your app will love it. 

The calendar and the date input, combined together, form the date picker—the ultimate date picking UI component. With it, you will be able to delight both the users who prefer typing and those who prefer picking the date visually. 

Bootstrap 4 Theme, and a Gorgeous New Sass Theme Builder

Bootstrap 4 has been in the works for a while, but make no mistake—once it is here, it is going to be huge, and we want to make sure that Kendo UI works flawlessly once you start your new projects with it. You can check out how all the components look on the preview page—if this is something you are after, go through the installation instructions. You want to make them look more like your brand? Tweak the colors in the theme builder, grab the _custom.scss and put it in your project. This will affect both the Kendo UI Components and the basic Bootstrap components. 

Curious for More?

To learn more about the new features of Kendo UI for Angular, sign up for the upcoming webinar on May 9th at 11AM ET. Or, if you can't wait until then, go ahead and explore what Kendo UI has to offer on the website.

Sign up for the Webinar

The second major release of 2017 for the Progress Telerik developer tools is here, and it’s jam packed with new productivity features. Read on for a breakdown.

As we get ready for the /build conference where we will come out in force (and yes, this means a pre-con party plus some surprises), we have some big announcements to make here at home.

Firstly, the new website look and feel—we hope it gets you to your favorite tools faster and more easily! In addition, now you have better visibility into the vast portfolio of the wider company—check out all that Progress has to offer! Some cool stuff for devs in there for many data-related scenarios.  

If you are going to be at the /build conference, please stop by the Telerik booth (#108) to see the latest bits in action. For the other millions of other .NET ninjas who aren’t lucky enough to grab one of the ~6000 /build tickets, there is a webinar for that! Also, note I am focusing on all things .NET here. For summary of the Kendo UI R2 2017 release, head over to Petyo’s blog post for Angular and Typescript fans.

But you are reading this post for the product news—right? So, without further ado, here is the Telerik R2 2017 summary. Go grab a coffee, there is plenty to explore here and ultimately improve your productivity.

Updates in the Telerik R2 2017 Release

• Telerik UI for Xamarin

We have 3 new components, Visual Studio templates and added new features to existing components. See it all at the Xamarin what’s new page and in this blog post.

• Telerik UI for ASP.NET MVC and ASP.NET Core

The already robust suite now has support for the Bootstrap 4 theme as well as the new Sass theme. See it all at the ASP.NET MVC what's new page and the ASP.NET Core what’s new pages.

• Telerik UI for WPF

A new Virtual Grid Control, Material Design Theme and tons of improvements and features for the already available controls. See more details at the UI for WPF what's new page and in this blog post.

• Telerik UI for WinForms

UI for WinForms is the first suite on the market with High DPI Support. We are also introducing a new Material Design theme and further improvements to our controls. See more details at the UI for WinForms what’s new page and in this blog post.

• Telerik UI for UWP

If you didn’t catch the news, we open sourced UWP controls under the Apache 2.0 license. That said, we are continually adding new features, and have added accessibility features to the suite. See it all at the UWP what's new page and in this blog post.

• Telerik Reporting

We have added Angular 2 support and ODBC support. See it all at the Reporting what's new page.

• JustMock

JustMock now comes with Visual Studio 2017 compatibility! See details at the JustMock what's new page and in this blog post.

Join Us for the Release Webinar

Come join Telerik Developer Advocates John Bristowe, Ed Charbeneau and Sam Basu for the Telerik R2 2017 release webinar. We’ll unpack the release to show you all the .NET ninja tools you can use right away!

Register for the Webinar

Looking forward to Microsoft Build 2017? So are we! There about bound to be some amazing announcements. We will be there too (booth #108), so make sure to stop by, meet the team and discuss the latest trends in tech, including our UI for UWP and UI for Xamarin. We have some cool SWAG too.

Micorosft /build starts in just a few days and the excitement around the event is growing by the minute. As usual, there are high expectations for the conference with large announcements by Microsoft and various sessions and talks by some of the biggest names in the industry.

Parties, Connections and Mingling

There is no question that Build offers great opportunities to connect attendees, be it around the conference floor or at the various surrounding events and parties, and we have already marked a few meetups on our calendars. We will be hosting a Progress Telerik party too, so should you arrive in Seattle a day sooner, drop by the TapHouseGrill after 7pm on the 9^th of May for a few drinks and snacks on us. Let’s get this conference started! RSVP here and get some cool swag too.

Progress at /build: Booth and Sessions

We wouldn’t miss the conference for the world and as usual the cool guys from the Product and Developer Relations teams will be present there. Head over and meet us at Booth 108, where we will have some great product demos and prize giveaways, as well as giving out our epic .NET Ninja Returns t-shirts.

Sessions

At Build 2016, John Bristowe talked about NativeScript and VS Code. It’s a great honor for us to have him speaking at the conference this year again. He will be hosting a session on “Creating Custom UI Controls in XAML,” focusing on the end-to-end control development of what is needed to ensure a great custom piece of UI. Stay tuned for details on the time and location.

Telerik UI for Xamarin Licenses for Free

If you haven’t had a chance to play around with our UI controls for Xamarin, you can get a product demo at our booth. You can also score one of 100 UI for Xamarin licenses by tweeting the answer to “What would you build with UI for Xamarin?” with #TelerikUIforXamarin.

What would you build? (Tweet this)

You can see the full terms, plus learn more about what we're up to at Build right here.

Telerik UI for UWP—Open Sourced

Windows 10 has seen growing adoption among desktop users and is now the second most used OS in the world, making up about 25% of the market. With this shift towards the new OS, more and more Win32, WinForms and WPF applications will have to be converted to UWP through the Desktop Bridge and many more will be created from scratch. In a survey over 52% of /build keynote watchers said they will move to Windows 10 soon because of Bash.

As usual, the creation of UI elements can be a handful, when it comes to timely delivery. However, if you are in need UWP UI—do not despair. As of the beginning of this year, UI for UWP is open-sourced and available on GitHub. You can get a UI for UWP demo by the same developers who build the product at our booth.

See You at //Build!

It has been a great year for Microsoft so far and we expect the conference to bring some more juicy announcements. Can’t wait!

We've got all the videos, demos, resources and prize winners from the big Kendo UI For Angular release bash!

Yesterday was the official launch of Kendo UI for Angular. It's a completely reimagined and rebuilt Kendo UI that finally brings Kendo UI to Angular in the best way possible. We had a lot of fun yesterday, and I'd like to thank our guests Long Le from Pioneer Natural Resources, and Stephen Fluin from the Angular team. If you didn't get a chance to see the webinar, or you were impeded by the sometimes flaky webinar platform, we've published the entire video to YouTube.

I've gone ahead and pulled out some highlights for you...

• Long Le from Pioneer Talks Standardizing on Kendo UI for Angular
• Steven Fluin from Google Talks Angular CLI
• Tara Manicsic Does aSick Getting Started Demo
• Burke Holland (moi) Explores How Kendo UI Works with AoT and Tree Shaking

Demo Resources

You can get all of the code that Tara used in her demo from her GitHub repo. You can also get all of my code and the Kendo UI Tunes demo that I built from GitHub as well. I even added functionality for visualizing the audio tracks with a Kendo UI SparkLine!

That project has some fun and interesting things to look at, including how to communicate between components using an Angular Service.

Of course, despite how compelling and magnificent each of those segments and demos are, what you really came here for was to find out if you are the lucky winner of one of our prizes yesterday. In case you don't remember or weren't able to make it, here is what we are giving away.

Prizes and Winners!

First off, the fine folks at Ultimate Angular are giving away five subscriptions to their amazing Angular video content. Ultimate Angular is widely recognized as a premier place to learn Angular, and we're all in the process of learning. To be eligible to win one of these licenses, you only needed to register for the webinar. Additionally, this prize is available anywhere in the world since we don't have to ship it! With that said, our five Ultimate Angular winners are...

• Milind Bansode
• Mark Orlando
• Mark Anderson
• Ryan Dowling
• Chris Bell

If you see your name on there, you don't need to do anything. We'll be contacting you to get your preferred email address to setup the subscription. Once we hear back from you, you'll be set!

The other item we are giving away is an XBox One S System.

We decided to give this to the person who asked the best question on Twitter, and let me tell you, there were a TON of them. Nearly 300 to be exact. It is always incredibly difficult to choose the best question since that it is such an arbitrary measurement. The way we do this is that 3 - 4 of us pick our favorite question from the Twitter interactions and then we pull in a larger group to vote on the best one.

This time around, our winner is Frik Strecker! Frik asked...

#heyKendoUI is there a way to have a single project sharing the core code between NativeScript and Angular UIs?

— Frik Strecker (@frikstrecker) May 9, 2017

Frik is already thinking ahead.

For those that aren't aware, we have an open-source project called NativeScript that allows you to build native mobile apps using JavaScript. This is not to be confused with hybrid (Phonegap / Cordova). These are truly native, the kind you would get if you wrote Objective-C or used Xamarin. The difference is that you code in JavaScript and use XML to markup the UI.

Because NativeScript uses JavaScript, it can also use Angular. In fact, we shipped first-class support for Angular in our official 2.0 release back in May of last year. Since Kendo UI is now built on Angular, and NativeScript has support for Angular, this indicates that you could share code between both web and native mobile projects. And you can.

We're still in the early stages of this integration, but you can check out two different resources to see how this works. The first is angular-seed-advanced from Nathan Walker. This is a seed project to help you get up and running targeting web, desktop (via Electron) and mobile (via NativeScript) all with the same Angular project.

You can also check out Jen Looper and TJ VanToll at ng-conf last year showing you how this works.

Congrats to Frik for winning the XBox One S! It's in the mail my friend.

NOW is the Time for Angular

With the launch of Kendo UI For Angular, we have ushered Kendo UI into a completely new kind of UI Component library. While Angular brings a lot of changes for those of us who come from jQuery backgrounds, we think that it also brings with it some enormous advantages in terms of performance and application structure.

You can get started with Kendo UI For Angular today. If you're still struggling to learn Angular, you can check out the Angular Tour of Heroes tutorial on their site. If your company is dead serious about investing in Angular, we recommend purchasing some quality video training from folks like our partners over at Ultimate Angular.

We're all learning together and it's ok to be confused or overwhelmed. The front part of the learning curve is everyone's least favorite part. Once you become familiar with Angular and its core concepts, it's truly remarkable how productive you can be.

A visual guide using animated GIFs to installing, setting up and building your first app with Kendo UI for Angular by Tara Manicsic.

Using Kendo UI components in your Angular application helps you make a robust application quickly with succinct code. When you’re working on a deadline, like during hackathon, or just a regular stressful deadline, like getting work to a client on time, coding faster is better. Having succinct, easy-to-read code is great when you’re working in a team or even just to future you. After all, you probably can’t even remember what you had for lunch yesterday (me either).

Okay, let’s get going.

Get Your Environment Ready

It is best to work with the latest stable version of Node & npm.

nvm install stable // to update to the latest stable version

// or if you want to keep you modules

nvm install stable --reinstall-packages-from=6.4.0
npm i npm -g // to update npm

Get Your Project Created

From the directory where you want your project to live, use the Angular CLI to create a new project. First, install the Angular CLI.

Then we just need to ask the CLI to create our new project and use the -ng4 flag to make sure we’re using version 4 of Angular (like all the cool kids ).

* update: with the release of 1.0 you no longer need the -ng4 flag, new projects will automatically be using Angular v4 (thanks CLI team )

ng new ATTACK -ng4

Ahhh, a fresh new project. To make sure everything is hunky dory, serve up the project and head to http://localhost:4200/ to take a look.

ng serve

In the words of Angular CLI contributor, @Brocco, BAM!

Get git…ing

Personally, I find that this is the perfect time to create a git repository and push the fresh project up.

cd ATTACK/ // move into your project directory
git init
git remote add origin <your repo's url>

Add all the things, then push.

git status // check all the files that need added
git add . // 
git commit -m 'initial commit'
git push origin master

I usually stay away from git add . because it can be dangerous but in this case we’re only sending up the initial files so

Now we have a reference point to when all things were good . I’ll make a commit to this repo with every new step we take. Just look for the to find the links to the new commits.

initial commit

Get the Progress NPM Registry

Get Access

If you haven’t worked with Kendo UI components you will want to set up an account here in order to access our registry. All of our component modules are distributed npm packages that live in our private registry but you just need your Progress Telerik account credentials to access them .

Once you’re set up, we can log in to the Progress registry.

npm login --registry=https://registry.npm.telerik.com/ --scope=@progress

If you get an error like this your credentials are not correct or you may not have activated your account. Check your email for an activation link.

Once you’re all set you should have this lovely ‘Logged in…’ message to greet you

Get the Chart Component

To use the Kendo UI components for your Angular project you will take the same steps, no matter which component you use:

• npm install the component’s module
• import the module & import the component directive in your module.ts file
• incorporate it into your template html file

Here we’ll look at the chart component so we can also look at some data binding. You can check out all the available components HERE.

Get the Module

First, you will want to install the module for our chart component and save it to your app’s dependencies with the -S flag.

npm i -S @progress/kendo-angular-charts @progress/kendo-angular-intl @progress/kendo-drawing hammerjs

You will see warnings like shown below but they are not detrimental to your project.

Get the Code in ‍

Inside your app.module.ts file you want to add the code to import the chart module, import the ‘hammerjs’ dependency and import the directive into your app module.

src/app/app.module.ts

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { HttpModule } from '@angular/http';
import { ChartsModule } from '@progress/kendo-angular-charts';
import 'hammerjs';

import { AppComponent } from './app.component';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    FormsModule,
    ChartsModule,
    HttpModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

If you’re like me and like to be safe rather than sorry, feel free to run ng serve again to make sure your app is golden ☀️.

install & import commit

Get Styled

In order for your app to look awesome with very minimal effort you can add the Kendo UI default theme. Again, you just need to install it with npm i then include it in your .angular-cli.json file.

npm install -S @progress/kendo-theme-default

For the fun part, we get to edit our .angular-cli.json file to include the theme .

.angular-cli.json

  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  "project": {
    "name": "attack"
  },
  "apps": [
    {
      "root": "src",
      "outDir": "dist",
      "assets": [
        "assets",
        "favicon.ico"
      ],
      "index": "index.html",
      "main": "main.ts",
      "polyfills": "polyfills.ts",
      "test": "test.ts",
      "tsconfig": "tsconfig.app.json",
      "testTsconfig": "tsconfig.spec.json",
      "prefix": "app",
      "styles": [
        "../node_modules/@progress/kendo-theme-default/dist/all.css", // 
        "styles.css"
      ],
      "scripts": [],
      ...

get styled commit

Get Data in There!

In the ‘component.ts’ file you can change your title and create some data to export.

src/app/app.component.ts

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'Winning App';
  private items: any[] = [{
    name: "puppies",
    data: [3, .65, 2, .50]
  },{
    name: "bunnies",
    data: [2, 1, .25, 3]
  },{
    name: "snakes",
    data: [1, .5, 1, .5]
  }];

get data in there commit

Get a Chart

Now you can add the chart component to your template and bind the data created in the component.ts file. We’ll keep the graph simple here because you still get a lot of interactions with just the basic graph but check out the API to see all the ways you can control and customize your chart.

First, the chart components <kendo-chart> and <kendo-chart-series> are added. Then, when you add the <kendo-chart-series-item> you can use *ngFor to loop through your list of items exported from component.ts and bind the items properties to the series item’s name and data. For this chart we set the type to area to create an area graph, but there are a lot of options for series or graph types in the Chart component docs!

src/app/app.component.html

<h1>
  {{title}}
</h1>

<kendo-chart>
  <kendo-chart-series>
    <kendo-chart-series-item *ngFor="let item of items"
      type="area" [data]="item.data" [name]="item.name">
    </kendo-chart-series-item>
  </kendo-chart-series>
</kendo-chart>

Now when you run ng serve you should find a beautiful, interactive chart!

Remember, you can always check in with the repo commits to see if your code changes match.

get a chart commit

Conclusion

That’s all you need to get started with Kendo UI components & even put a chart in your app! Good luck with your app

Resources:

• Components Home Page
• Charts Docs
• Charts API
• Angular CLI Repo

Related content:

• Planning An Angular Application (white paper)
• Conquer Angular UI Faster and Easier with Kendo UI for Angular (webinar)
• Kendo UI Roadmap

This post is part of a series featuring our Developer Experts—community members who represent the best of our products. Feel free to read about our other featured experts and meet more DEs.

Johannes Hoppe is our latest interviewee. Hoppe is a freelance developer based out of Germany. On the side, he also writes books and speaks at local technical conferences.


Johannes Hoppe

What is your background, professionally?

I'm a freelance web developer, book author and speaker for technical conferences from Germany. I lead the .NET User Group in Rhein-Neckar, too.

Where are you based and why?

I live next to Heidelberg—I studied here and like the area. It's warm and sunny here, with a nice countryside for rides and vintners everywhere. I walk twice every day with my dogs in the woods, it's really great.

With whom are you working?

I'm an IT consultant by day. So, every year or so I switch both the team and the project. At night, I do a lot OSS, although managing the amount of PRs and open issues is a challenge right now.

What projects are you working on now?

We're currently working on a completely new Industry 4.0 portal for a DAX-100 company using Angular with Kendo. My biggest private project is our Angular book. We are currently polishing the code examples for this book and its new website. There is always work to do for this publication!

What’s the most interesting project you’ve done recently?

Writing this book!

Which of our products do you use and why?

I'm focused on Kendo UI v1 and v2. I also do a bit of NativeScript and work with Telerik Platform here and there.

What are some challenges you are encountering now in your work?

We have a ton of AngularJS 1.x code which needs to be migrated, which is no fun.

From your experience, what’s the biggest software pain point that your partners/clients encounter?

That's clearly the migration from AngularJS 1 to Angular 2/4. You really need a lot of budget and resources to do this properly. Also, a lot of known Angular libraries have no adequate Angular 4 counterpart. A second heavy pain point is the lack of OData in ASP.NET Core. OData works great for third-party controls like the Kendo Grid. The missing roadmap for OData+Core prevented two of my last customers to fully switch to .NET core. It's really unfortunate that this essential feature is missing.

With the R2 release of Progress Telerik, we're going back to our roots—we're giving you the tools you need to be the best possible .NET ninja.

The sun is shining. The weather is warming up. The flowers are blooming. The birds are chirping. Yep, it is summer time for most of the world, so step out and enjoy the great outdoors. Unless, of course, you are in Australia—but then you’re probably already brave enough to fight off the wilderness and get plenty of outdoor time regardless.

We're hoping the R2 release of Progress Telerik will help you get out of your cubicle a bit and enjoy the great summer weather. We know that to deliver your awesome software projects on time and delight your users, you need cutting-edge developer tooling. You need tooling that will elevate your development experience and enable you to deliver solutions faster.

No matter your app platform—mobile, web or desktop—this R2 release will help you improve the way you operate. We’re getting back to our roots and making the best .NET tooling for .NET ninjas, like yourself. Your success is our business.

Relive the Content

On May 25, Progress Developer Advocates John Bristowe, Ed Charbeneau and Sam Basu unpacked the Telerik  R2 release with a developer’s perspective on the juicy new bits. Yes, there were slides, but the demo gods were happy with us as well. If you had joined us for the release webinar, a sincere thank you! If you missed it, you can relive the webinar in all its glory via this high-definition recording.

Prize Winners

What’s a Progress webinar without some awesome prizes? Our first gadget pick this time was the Amazon Echo—because life gets lonely without Alexa.

And the winner for the best question goes to Chris Sutton!

Our next gadget giveaway was the Parrot Bebop 2 Drone—because geeks dig aerial photography in HD.

And the winner is Duane Moore—you win just for showing up.

Congrats winners. Hope you enjoy your prizes!

Additional Question & Answers

One of the most enjoyable aspects of our webinars is the audience interaction and Q&A all throughout. We appreciate developers bringing up real-world questions and concerns on the latest technologies.

While we tried to answer as many questions as we could on air, here’s an excerpt of some short Q&A topics that were important to resurface:

Q: Are the ASP.NET UI widgets shown available for both MVC & Core?
A: Yes. The TagHelpers are exclusive to UI for ASP.NET Core, but all widgets are available for MVC as well.

Q: How do we prevent freezing of a UI grid with unlimited data while binding?
A: First, you should always be conscious of the amount of client-side data you bind to UI grids. Having said that, most of our Grids (ASP.NET, UWP, WPF, etc.) do virtualization and smart data binding through lazy loading. Check this out.

Q: Is there RTL support in Kendo UI?
A: Yes, both Kendo UI for jQuery and Kendo UI for Angular support RTL features.

Q: When will Kendo UI for MVC support the Scaffolder Wizard within Visual Studio 2017? I still keep VS2015 in addition to VS2017 just for this purpose alone.
A: The Scaffolding Wizard is already available for VS2017 when using UI for ASP.NET MVC. If you're not seeing this functionality, try updating to the latest release.

Q: With Kendo UI, do I now have to choose between jQuery and Angular?
A: Nope, technology stack is entirely your call based on your expertise and type of app you are building. We want to enable you to render sharp UI no matter your approach—hence, the choices in Kendo UI.

Q: Can more than one signatory sign a PDF?
A: RadPdfProcessing currently supports only signing of a single signature field. Signing more than one signature field will result in invalidation of all signatures except the last one.

Q: Is there a big gap between Kendo UI ABL vs .NET in term of features/support?  We are working in an ABL environment but we are looking toward .NET for new apps.
A: Perhaps a bit in tooling, but we've worked hard to bridge that gap. Check this.

Q: Can I use different map providers with the Kendo UI Map control?
A: Yes, check this.

Q: I do not see a way to adjust anything but colors in the WPF Theme Generator and the MaterialPalette class has nothing related to margin or padding.
A: Customize the control template instead, like here.

Q: Are the shapes for the rating control in UI for Xamarin a fixed set or are they customizable?
A: There are several pre-defined shapes, but you can also customize. Check this.

Q: Is online documentation updated for all .NET products shown?
A: Yes, docs are updated the day of the release and reflect latest bits.

Q: Get Out! Your Ninja Skills are sweet. How are we going to justify the ‘long time’ it takes to develop complex UI functionality ever again?
A: We have teams of smart engineers working non-stop to produce these UI controls, so you can focus on solving real-world problems. Enjoy!

Q: Is John Bristowe a cyborg?
A: Close—he’s Canadian.

Appreciate the Love

Hosting webinars is hard work. But we do it because we’re excited about our releases and want fellow developers to be successful. We always appreciate your kind words and strive to make your lives even easier as developers. Here’s some love:

• https://twitter.com/temeschede/status/867761866084429824
• https://twitter.com/LBlumenfeld/status/867762616189538307
• https://twitter.com/BrianWright/status/867762490276552704
• https://twitter.com/easyprotechnlgy/status/867771636719779841
• https://twitter.com/easyprotechnlgy/status/867764378870976515
• https://twitter.com/aharmsdev/status/867759904966270976

Resources

There are tons of things to point out, but it is often best to start at the product pages. From there, you can drill down to UI features, demos and docs. So here goes:

• Webinar Recording
• Telerik UI for ASP.NET MVC
• Telerik UI for ASP.NET Core
• Telerik UI for ASP.NET Ajax
• Kendo UI
• Telerik UI for Xamarin
• Telerik UI for UWP
• Telerik UI for WPF

That’s a Wrap

With Microsoft’s renewed mojo and cross-platform tooling, this is probably one of the best times to be a .NET developer. Your professional apps need polished modern UI though—stop reinventing the wheel and ship your apps faster.

Progress Telerik .NET tools are here to help, providing you with a rich complete .NET UI toolkit and frameworks for all applications, including web, desktop and mobile. Hope we have given you plenty of ammunition with this R2 2017 release to go build amazing apps. Stay classy and have fun coding! 

Catch up on the questions we couldn't answer live, and learn more about the latest features in Kendo UI for jQuery and Kendo UI for Angular.

Earlier this week, we held the Kendo UI R2 2017 release webinar, which highlighted the latest features we’ve added to Kendo UI for jQuery and Kendo UI for Angular. This webinar was hosted by members of the Developer Relations team at Progress. This release represented a significant milestone for Kendo UI as we hit v1.0 with Kendo UI for Angular. This blog post summarizes the event and provides answers to the questions that were asked by attendees.

Webinar Recording

If you were unable to join us for the live webinar, don’t worry: we’ve posted the recording to our YouTube channel.

Prize Winner

We love prizes and giveaways. Who doesn’t? A Kendo UI release webinar wouldn’t be complete without some epic prizes! The best question was asked by Adrian Alvarez during the webinar. Congradulations Adrian, you’ve won an Xbox One S.

Questions and Answers

During these webinars, we field a lot of questions. We try to answer most of them. However, it’s hard when you have thousands of attendees asking questions simultaneously. That’s why we provide the webinar recap, so you can see the answers yourself.

Any plans to offer a UI reporting feature that can be easily incorporated into Angular applications?
Can you show us the reporting capabilities of Kendo UI?
You’ll want to check out Progress Telerik Reporting. Our web report viewer is built with Kendo UI. And here’s even better news: we just released an Angular-based report viewer. Please make sure to check out our interactive demos of the report viewer.

Could you please update your demos with every release to help us better understand how to use your product?
We ship new and updated demos with every release of Kendo UI. You can see new ones marked on our Kendo UI demos page. Updated demos are also marked as well (i.e. Grid demos).

Will the Sass-based themes replace the Less-based themes in the future?
All Kendo UI widgets arrive with a number of predefined themes. As of the R1 2017 release, the Kendo UI distribution includes Sass-based themes. We do not have plans to deprecate our Less-based themes.

Will the Progress Sass Theme Builder be updated to allow for a custom build of the theme file similar to the custom build tool for the JavaScript components?
The Progress Sass Theme Builder allows you build a theme from scratch based on our default or Bootstrap 4-based themes. You can also import an existing theme. The tool then allows you tweak the theme to your requirements. No custom build tool or step is required.

For the Progress Sass Theme Builder - for the import section - does that mean for future updates release, I can import my previous theme to get an exported updated theme?
Generally-speaking, this should work. If new components are added, they should be injected into the theme after being modified. However, just like most things involving software, it depends.

Are there plans to have a Material Design theme?
At the time of this writing, support for Material Design is slated for the R3 2017 release of Kendo UI.

Is Kendo UI for Angular free?
The price of Kendo UI and its support options are available online.

Any plans on porting the TreeMap or creating a HeatMap chart for Kendo UI for Angular?
Not at the moment. However, our long-term goal is feature parity with Kendo UI for jQuery while keeping pace with the Angular framework development. We’ll review our feedback and share our plans for R3 2017 later this year.

Does Kendo UI support Angular 4?
Yes!

How can I color Grid cells and Grid rows (i.e. foreground, background) depending on values of other Grid cells?
You can define a cell template to emit a binding that will respond to changes made to the underlying model. This can include styles applied to the markup such as a foreground color.

Is the Grid component in Kendo UI for Angular responsive?
Please see Responsive Features for an overview of the responsive capabilities for the Grid component.

How many Angular releases on Telerik/Progress UI components can we expect in one year?
We ship three (3) major releases each calendar year with service packs and updates in-between each release.

How can I use the current Kendo UI for jQuery with Angular 4?
How can I use the Editor widget in Kendo UI for jQuery with Angular?
Can I mix widgets from Kendo UI for jQuery with Angular widgets?
Please see Kendo UI for jQuery Integration for more information on this topic.

Do you have a guide showing how to release a project without using Angular CLI?
The best place to start is our Get Started guide. From there, you can check out the links we provide to building a project with/without the Angular CLI.

Will there be more charts introduced in the future?
Keep an eye on our Roadmap for Kendo UI for Angular for future updates. In the meantime, please send us your feedback if you have any suggestions on charts that you’d like to see added.

How can I use a context menu within a Grid component built with Angular?
I would recommend using a template to define the context menu along with the event handlers needed to trigger its appearance.

For software development shops that rely heavily on continous integration (CI) to build/release software, is there an easy way to incorporate these Kendo UI Angular components into automated pipelines?
I recommend checking out the article we’ve published entitled, Build Agents Authentication for more information about this.

Are there any plans to add a debounce feature to Angular controls like combobox so that change events are not fired until the user is finished typing?
It’s not on our roadmap at the time of this timing. However, please feel free to submit your suggestion(s) to our team.

Is there a Visual Studio template for Kendo UI for Angular?
Not at the moment. However, npm is integrated so you’re good there.

Do you plan to add an option to “remember” the state of filters, sorting and/or selected page for Grid?
It’s supported via the getOptions and setOptions methods on the Grid widget in Kendo UI for jQuery. You can check out the demo of this feature online: Persist State. For Kendo UI for Angular, it’s definitely something to consider. Please submit your feedback: kendoui-feedback.telerik.com.

You’re putting a lot of resources into the Angular version. Is it your advice that we should build our new projects using Angular instead of jQuery?
Absolutely not. My advice is to use what makes you happy because we support both and will continue to support both for a long time to come. :)

Is Yarn supported instead of npm?
At the time of this timing, the Yarn package manager does not support private packages. For more information on this issue, refer to yarnpkg/yarn#521.

I don’t want to export the Grid as PDF because there is additional information on a page. How can I print a grid with other information on a page?
In Kendo UI for Angular, the Grid component supports both PDF and Excel export. We may look into other formats in the future.

We use Kendo UI with SharePoint. Are all of these libraries and components usable in SharePoint 2013 on-premise and able to query SharePoint data?
Yes! In fact, we wrote a whitepaper about this that you can check out on our site, Office 365 and SharePoint - Kendo UI for jQuery.

We recently kicked off our "Kendo UI DevChat" series on web development. If you missed it, check out the replay as we answer questions we couldn't get to live.

This week saw the first installation of our "Kendo UI DevChat" series aimed at tackling important topics around web development with a hands-on, code-only, presentation style. This first webinar was a session on best practices around building user-friendly forms with Angular. While focusing specifically on Google's Angular framework, all of these best practices can be implemented in any web form and could work across server-side (ASP.NET Ajax, ASP.NET MVC, JSP, etc.) and client-side implementations (jQuery, ReactJS, VueJS, EmberJS, Aurelia, etc.) alike. I wanted to summarize the event in a blog post to not only share the recording and project we created but also answer some questions that came through.

Webinar Recording & Sample Project

If you were unable to join me for the live webinar, or just wanted to see it all again (who wouldn't!?) we have the recording right here on our YouTube channel.

As for the sample project, you can find it right here on GitHub.

Questions and Answers

There were a ton of questions asked during the webinar but I wanted to highlight a few of them here since I think anyone that has watched the webinar will find them useful.

Which version of Angular and Angular Forms was this?
This particular webinar used Angular 4.2.2. The package.json for the solution has set up the Angular reference as "^4.0.0" so it should remain within 4.x.

Will this work with reactive forms?
First off, in case you're not familiar with Angular's reactive forms, here's a quick link to the Angular documentation. While what we did during the webinar was an example of a template-driven form, all of the best practices we brought up in the webinar will work for any type of approach to creating forms. So, with some tweaks to the approach (to make it reactive) we can still re-use most of the code from the webinar.

Are there best practices for what to do once a form is submitted? E.g. going to a new screen, popup message, etc.
We did just take a look at the form portion during the webinar and the answer becomes "it depends." This form could have already been in a popup, or maybe it was just a sign-up form. What to do next pretty much depends on the application requirements, but I would say that transitioning to the next screen is probably the most logical. If you want to have a success message I encourage that to be under the button area with green text stating success, then moving on to the next screen. A popup to declare success is too distracting.

What is your approach for nested forms validation using Template Forms you used?
Nested forms would most likely involve another Angular component rather than having a single overly-complicated component. We can then do validation within each of the components independently. Also, since we are doing validation on a field-by-field basis (rather than the full model upon submit) this also reduces complexity of validation in this case. Absolute worst-case scenario, if you need to communicate between two components, you can set something up in your service layer to deal with the communication.

If this would be a child component. How would you respond back to the parent component? What's the best practice to use this within another component?
The above question is pretty much related here. For any communication between Component A and Component B in Angular one should work with the service layer to push information back and forth. Rather than passing information from parent to child (or vice versa) I would suggest having the parent send information to the service layer and have the child pull data from there. You can of course pass data between components directly if need be. This documentation article in the official Angular docs dives more into this topic.

What is the best practice to set fixed height for validation (error) message? So that it doesn't move all elements below it.
This is something that I did not do in the webinar, but it's a great idea and I wish I had included it! Yes, not making the form elements move around is also a great practice in forms. Any kind of movement or shift in elements placement can be distracting to the user.

Are there other k-classes for laying out labels to the left?
Yes! Instead of using "k-form" we can use "k-form-inline." There's even more classes to use for forms so I recommend reading over the Kendo UI for Angular Form documentation section for more information.

How heavy this application becomes at the end with all those libraries loaded?

While yes, I did leverage Kendo UI for styling for my form elements, I did only include two actual widgets, the DatePicker and the Switch. For everything else I was merely using CSS classes to help improve the look and feel—even with the form layout! So, we're not really adding any bloat to the project since we're working with CSS classes to spruce things up a bit.

When we start working with more advanced components and Kendo UI we don't have to worry, because Kendo UI supports Ahead-of-Time (AoT) Compilation and Tree Shaking to reduce page bloat.

What IDE you are using and how we can leverage the Kendo UI components in this IDE
For this demo, I was using Atom, but you can use just about any IDE out there to work with Angular and Kendo UI. Visual Studio, Visual Studio Code, Sublime; really any text editor can work with these technologies.

This post is part of a series featuring our Developer Experts—community members who represent the best of our products. Feel free to read about our other featured experts and meet more DEs.

Jorge Cano is our latest interviewee. Based in Argentina, Jorge is a Google Developer Expert in Web Technologies skilled in JavaScript Architecture and well-versed in writing, speaking and teaching.

Jorge Cano

What is your background, professionally?

I'm a self-taught JavaScript Architect.

Where are you based and why?

I live in Buenos Aires in Argentina, my home country.

With whom are you working?

I work at a company called ByteDefult as a Full Stack Developer. I'm lucky to work with several other terrific, skilled colleagues.

What projects are you working on now?

ByteDefult is a startup, and we're creating a super secret video-based product yet to be released. We look forward to its release, and I think you will, too!

What’s the most interesting project you’ve done recently?

I'm writing a module for Angular to use drag, drop and upload, coming soon to npm. I'm also mentoring a large team of Spanish-speaking NativeScript Ambassadors, younger developers who are learning NativeScript this summer. In addition, I've written a book on Angular (Entendiendo Angular) and am considering writing a book on NativeScript. Finally, I'm working on a project called 30 days with RxJS in Spanish.

Which of our products do you use and why?

NativeScript! I love its simplicity and its use of Angular. When I read the code behind NativeScript, I found it was amazing. I'm excited to write a book about NativeScript, and I've also use Kendo UI many times for web development.

What are some challenges you are encountering now in your work?

When you are in a professional environment with amazing, interesting and intelligent colleagues, the architecture and ideology of a product becomes something incredible. You are challenged to always get better and push technologies to create even more interesting products. That's a good kind of challenge—a tougher challenge is to write your own Open Source project and maintain it, but you need to do this to keep moving forward and surmount difficulties.

From your experience, what’s the biggest software pain point that your partners/clients encounter?

After reviewing demos and documentation (and scouring the forums for threads relating to your issue) you’re still unable to implement an app requirement, or determine if you’re dealing with a bug, don’t despair! If you’re a licensed developer covered by a valid support contract, or within the evaluation period, you have the option to work directly with knowledgeable Progress staff by submitting a support ticket.

What You’ll Need

Prior to submitting the ticket, you should gather the specifics of your development environment. These will be needed for our developers to better understand the context of your issue. Depending on the platform, this usually includes the following:

• Full version number of the Telerik control or product being used
• Operating system details of your development machine/server
• Browser type and version number (when applicable)
• .NET Framework version (when applicable)
• Visual Studio (or other IDE) edition (including Service Packs)
• Preferred coding language (C#, VB.NET, Java, PHP, etc.)

Identify all applicable code that is required to clarify the issue. We strongly recommend that, whenever possible, you take the time to isolate the problem in a sample project. A simplified, runnable, standalone application that demonstrates the issue allows our developers to immediately focus on resolving your issue and saves the time needed to first reproduce it. This helps avoid excessive back and forth correspondence, which extends the time required to resolve the issue, and improves the chance of solving it immediately.

Finally, you should prepare a clear written overview of the issue, and create applicable screenshots or video captures that visualize hard-to-describe behaviors or layouts.

Creating the Ticket

Log in to your Telerik Account and using the dropdown menu provided, click on "Support Tickets".

Then, click the "Contact Support Team" button and choose the product for which you need support.

If, after reviewing the most popular support resources for the given product, you still have a support question, you may start typing it in using the dialog provided:

After submitting this form, you'll see that we do a quick search to find any relevant support resources for you. Assuming there are no matches (be sure to look closely!) you can click the "Submit Support Ticket" button to proceed.

At this stage, you can classify your ticket as a Support Ticket, Bug Report, or Feature Request:

Don’t forget to use the “Attach files” button to upload your supporting files which should include your code and/or screen captures. The allowed extensions are .zip, .rar, .jpg, .png, and .gif, and the total combined size of the upload cannot exceed 20MB (feel free to contact us for help in uploading larger files). Finally, users holding our DevCraft Ultimate License have the option to “submit ticket for pre-screening” which means that we’ll do a quick check and tell you if you've provided sufficient information for the developers to understand your issue and provide helpful insights.

Once you've double-checked that all is in order, simply click the “Submit Ticket” button to initiate the ticket.

Follow Up

You should receive an immediate email confirmation of the ticket in the inbox of the registered email account, featuring a copy of the ticket details. Then, you can monitor your inbox for an email notification of the reply that has been added directly in the ticket by the Telerik support team. This can be expected within the ticket’s time frame as specified in your support contract (typically 24 hours), or evaluation agreement (typically 72 hours). You can reference the time frames offered by the various support plans here.

In the response to your ticket, you may be asked to provide additional insights or supporting files. You can reply to the ticket accordingly. If the response provided does not solve the issue, you can continue the thread until a resolution is found. Any new, unrelated issue should be logged in a separate ticket. Once you've resolved the issue, please use the “Mark as Resolved” button/link to close the thread.   

Editor's note: This post was originally written by Georgi Tunev in 2013, and has been updated for completeness and accuracy.

This week on our "Kendo UI DevChat" series on web development, we cover exporting HTML to PDF. If you missed it, check out the replay as we answer questions we couldn't get to live.

Continuing our popular Kendo UI DevChat webinar series, this week we took a look at a very popular framework feature of Kendo UI: Exporting HTML to PDF. During the webinar we covered how to export generic HTML, advanced UI widgets (like the ones found in Kendo UI), exporting the Kendo UI Grid and its full contents to PDF, and how to customize these PDF documents through various configuration options. This focused mainly on code written with jQuery, but we also took a look at how the core framework can be accessed within Angular.

Webinar Recording

If you were unable to join me for the live webinar (or maybe you just want to re-watch it since it was so great!) we have published the recording on our YouTube channel.

This time around there is no sample GitHub project as the demos were fairly simple, but I do want to highlight our PDF Export live demo (which covers exporting to PDF, Image, and SVG), our demo of exporting Grid content to PDF, and the PDF drawing documentation section.

Questions and Answers

As always there were a lot of good questions coming from the crowd during the dedicated Q&A section of the webinar, and while I answered quite a few during the webinar, I also wanted to answer them in this blog post since it's easier to have on hand!

Will the styling/CSS you use with your HTML be displayed correctly in the exported PDF?
Yes indeed! We take the HTML elements and their applied styles into account when creating the HTML that is being exported. We try to make it as faithful as possible to your current state of HTML.

Can you export your own HTML using Kendo UI?
Yes, you can definitely export your own HTML! I took a bit of HTML that is generic to showcase how it can be done without being Kendo UI specific, but this can go beyond simple HTML elements.

Can you exclude HTML elements from the drawing area?
This is an interesting question, but right now there is no automatic way to take child elements within the overall HTML element you're passing and exclude them from the export.

What you could get away with is applying some "display: none;" styles throughout your document during the export phase (before you call drawDOM) and then use the promises (.done() is a good time to do this) to revert these styles again.

Are Chinese characters also supported?
Yes! This falls under the ability to use custom fonts in the PDF document that you're exporting, and this documentation section covers how you can include these fonts.

How about unicode characters?
Unicode characters are also supported but they are dependent on including the fonts they are a part of of like mentioned above.

What is needed for the proxy server used with proxyURL
There is nothing Kendo UI specific that we do with the proxy and it is not tied to a specific server-side technology. You can add this proxy as an end point to your existing REST API if desired. All that is needed is to accept three parameters coming from Kendo UI (contentType, base64, and fileName). Then the proxy should return the decoded file with the "Content-Disposition" header set. More information on what is needed in this implementation can be found under the saveAs documentation section.

Is RTL text supported?
During the webinar I mentioned that this should be possible, however I was mistaken—sorry for misleading anyone about this! Currently RTL is not supported in the PDF exportation feature of Kendo UI. If you'd like to see this added in the future please vote and comment on this feedback portal item.

What was the configuration of the Grid to export all of its data?
All the code was taken from this Export to PDF demo from the Kendo UI Grid demos.

Is it just toolbar: ["pdf"]? Is more code needed?
Honestly it's just as easy as setting the toolbar configuration option and including "pdf" in there. If you want more control over the resulting document you can use the "pdf" configuration option as well, like in the demo linked in the previous question.

Let's say I need to export page no 12, how can I do that?
You would have to programmatically go to the desired page of the Grid by using the underlying DataSource object's page method. Once that has been done you can export the rendered Grid page!

How does Kendo UI deal with a Grid having too many columns to fit in the pdf width wise?
We follow whatever is provided on the page currently. So, if no specific changes are made ahead of time and if no templates are used then whatever is currently displayed on the Grid (and however it is displayed) will be exported.

One could define a template like we do in our Grid PDF Export demo and help make things a bit more customized through CSS to ensure that everything fits nicely.

Beyond that you could also show and hide columns of the Grid to only export the most important columns of the Grid.

Does Kendo UI provide any headless browser, so that the UI can be exported to PDF in scheduled scenarios
While the export to PDF feature does not require one of our UI components, just the framework feature itself, we do not have anything specific around scheduling to help in this scenario. You would have to trigger this JavaScript code in some way to export the content currently displayed in the web page.

Can you generate PDF files on the server side with Kendo/Telerik?
Yes you can! This uses RadPdfProcessing which is available within all of our .NET UI product suites. Here, for example, is a demo that showcases the integration with UI for ASP.NET AJAX. One would need to have this .NET assembly included as a reference on the server in order to export PDF on the server-side—even with Kendo UI on the front end!

Is it possible to have grouping server side export for Excel using for large data sets?
This would be done through RadSpreadProcessing, the Excel-equivalent of the PdfProcessing library. It is certainly possible, but when it comes to large data sets one has to consider memory on the server-side as well. Nonetheless, offloading this to the server is a great way to deal with large data sets!

If you want a quick introduction, this first blog post in a series can help give you insight in to RadSpreadProcessing.

Is it compatible with Angular 4?
Yes! Later in the webinar I showcase how Angular (2+) is supported as well.

Is there a way to just have a single header and footer for the entire document, not on each page?
Currently the template functionality that we showcased is on a page-by-page basis. If you'd like to export a single header and footer on a document (header on the first page, footer on the last page) this is currently not something that is supported. Feel free to submit this as feedback for future iterations of the framework!

Are there limitations around size of exporting to PDF?
One has to keep in mind that all of this is being done on the client and the proxyURL isn't a offloading of the PDF generation to the server - it's just there to start the automatic download of the PDF file in browsers that do not support the File API. Due to this the limitations around exporting mainly comes from the browser being used and how well it can handle all of this JavaScript in memory. If you are running in to specific performance issues I recommend submitting your specific scenario in a support ticket for help from our support team!

Free and open source software can be a convenient and inexpensive way to add functionality and reduce development time, but only if you make right choices.

Without the reuse of blocks of existing design components, or “IP” (Intellectual Property), we would constantly be reinventing the wheel. On each new design project we’d have to start from scratch and design the entire system from the ground up. Using existing components lets us build added value with new functionality, while re-using the components that we have designed before.

Every design field does this, whether it’s a mechanical design for a new engine that reuses an existing turbine assembly, or an electrical hardware design that reuses an existing USB interface, or a software design that reuses a module that handles encryption. Productivity is enhanced, designs are advanced, and everyone wins.

But it's important to make this choice carefully, because if you make the wrong choices it can have the exact opposite effect. There are a number of important factors to take into account when considering the use of someone else’s design component.

1) Will it actually help?

One of the first considerations is to explore whether the function you’re looking to add actually helps differentiate your product. This might mean creating that component yourself and adding in features that no one else has, or it might just mean using the best available 3^rd party component you can find. In some cases it might not be possible to create a better component than what is currently available, and in others it might not be worth the effort because that component is not part of your core functionality. Think carefully about what parts of your product makes sense to design yourself, and what parts are best outsourced.

2) Where does it come from?

The next consideration is the source of any 3^rd party components. In the software world, probably more than any other design discipline, there are a lot of options available. In addition to actual open source, there are many alternatives that are provided free of charge, even if the source code is not actually available. Free is obviously good from a budget perspective, but you need to consider the actual cost of a component that might require customization, or work-arounds, or support and bug fixes. In any case, not all the components you might want will be available for free.

One key aspect to consider when looking at open source components is what organization is behind it? A component driven by a handful of individual users may be very different than something driven by a company (like Angular backed by Google) or well established development project (like jQuery backed by the JS Foundation).

3) Does the license meet your needs?

Once you have decided to use an existing component, one key aspect to consider is exactly what type of license it comes with. There are licenses like the Apache 2 license, used by the Android operating system, that allows you to use a component in your product and still charge money for your product.   The MIT License, used by jQuery and Ruby on Rails, is similar but requires a copyright notice to be included in the end product. The GNU General Public License (GPL), used by the popular GNU operating system and other projects, is based on the idea of a “copyleft”, which means that all derivative work must also adhere to the same licensing rules.

There are licenses that allow for educational use, personal use, non-commercial use... and even with regular paid licenses there are composed of royalty and non-royalty licensing (do you need to pay a royalty on each copy of your product sold?). Another important part of the licensing discussion is the existence of any patents that might impact your ability to use the component.

The point is that you have to be very careful when you look at any component source to make sure that the license lines up with your intended use. You’d be surprised how many times this gets overlooked, especially in start-ups and smaller companies.

4) How much risk can you afford?

Another key consideration is the level of quality you require for your application. Obviously we would all like perfect quality in everything, but quality usually comes with a cost, and higher levels of quality are not always required. If you are working on a classroom project, or a website for your son’s Boy Scout troop, you can afford to take on a little risk. If there is a problem with your application in situations like those, the impact is minor.

If, however, you are creating an application that people will use to access their financial information or control a nuclear power plant, you will have very little tolerance for risk and will need to make sure the components are high quality. This is one area where software has an upper hand on physical designs like integrated circuits or mechanical parts. Software designs can usually be updated easily and quickly if needed, although significant damage can still occur before the bug is found and fixed.

5) How do you judge the quality?

Unfortunately, there is no golden bullet for determining quality. Instead you will want to examine some parameters: how long has the providing organization been in operation, how many people use the product, how extensive is their testing, what are the perceptions from the other users, etc.

If you purchase a component from a company, then you have someone you can directly hold accountable for any quality issues, and whose actual job is to fix them. With an open source component you might be able to track down the contributor but whether or not they even acknowledge the issue let alone fix it is not a given.

6) Is there support?

The follow-on issue to quality is support. Support ranges from having someone to fix any problems that might arise to helping you use the components properly. Even if the component itself is perfect, it usually has to interface with a variety of other code. Those modules might change either in functionality or even in their interface, and then you might need to quickly fix your code to work with the new environment. Most of us have had experiences in the past where we have received an OS patch and suddenly had one or more programs, that worked fine until that point, develop bugs or stop working altogether. It is usually incumbent on the application provider, not the OS vendor, to make the fix.

7) What format do you need?

You will want to consider whether or not you have access to the original source code. With most interpreted languages (primarily client-side web languages like HTML and JavaScript) you can obfuscate the code but not actually compile it. Most other languages (C++, Java, etc.) can be compiled to protect the source code. If you have high confidence in the provider of the component, source code is neither required or even wanted in most cases. If you are using open source components, however, you might end up having to patch the component yourself and access to the source code can be important. You can compromise by having escrowed versions of the source code, but this extra overhead is usually more applicable to full applications and not individual components.

8) Does its roadmap match yours?

Finally, is your application a one-time creation, or will it grow with you? If it is going to be an ongoing product for your company or organization, you will probably want the source of your components to update and enhance their components as well. How much control will you have over their roadmap? How much insight? Do they even have a roadmap?

Open source components are often enhanced on an ongoing basis, but with less certainty. You can request that a new feature be added to an open source project, but you may have to develop it yourself.

These are all just a few of the considerations you need to think about when using design components from a third party. Making the wrong choice can decrease sales or even involve you in a lawsuit. Making the right choice can enhance your product, increase your product quality, and shorten your time-to-market.

Case study: Kendo UI

Let’s walk through an example evaluation of these eight points using Kendo UI, our platform for building beautiful and data-rich web applications.

A Long History of Supporting Developers

At Progress we have a strong track record of standing behind our products with world-class support for developers and continued innovation. Curious to try Kendo UI out for yourself with a free 30 day trial? You can learn more here.