Quantcast
Channel: Infragistics Community
Viewing all 2223 articles
Browse latest View live

Creating an Infragistics Xamarin.Forms Data Chart

$
0
0

[youtube] width="560" height="315" src="http://www.youtube.com/embed/Qb0TcHjIw0U" [/youtube]

Welcome to our video tutorial for creating a Data Chart with Infragistics XamarinForms. In this video tutorial, you should already have set up your computer for working with Xamarin.Forms (including Android, iOS, and Windows Phone platforms).

We’ve created a new blank app project in visual studio,  (using Xamarin.Forms portable template). Your application should be targeting XamarinForms v1.3.5.6335 or later and you have already watched our other "Getting Started with Infragistics Xamarin.Forms" video.

First, we need to add a new Xamarin.Forms XAML Page and set it as the main page of  the portable project. Therefore, we right click on the project, select Add – New Item… menu item and then select Xamarin.Forms XAML Page template. We change name to ChartPage and click the OK button. Now we change the MainPage property of the Application in the App.cs file to the newly created ChartPage.

In the XAML page, we need to add Infragistics namespace declaration for charts assembly and the local application. Note that we also need local namespaces because we will create an instance of the data source that will be implemented in this application:

xmlns:ig="clr-namespace:Infragistics.XF.Controls;assembly=InfragisticsXF.Controls.Charts"

xmlns:local="clr-namespace:XamarinApp;assembly=XamarinApp"

 

The Next step is to add Infragistics Data Chart to the XAML page by changing the content of this page to an instance of Data Chart control:

 

< ig:XFDataChart x:Name="Chart" >

    < /ig:XFDataChart >

 

Now, we need to add Category X-Axis and Numeric Y-Axis to the Axes collection of Data Chart. Note that ItemsSource property on Category X-Axis is set to context binding of the chart and this axis has Label property mapped to data column named “Date”. I will go over and explain in detail the process of data binding later:

        < ig:XFDataChart.Axes >

            < ig:NumericYAxis  x:Name="yAxis"   />

            < ig:CategoryXAxis x:Name="xAxis" ItemsSource="{Binding}" Label="Date" />

        < /ig:XFDataChart.Axes >

 

Next, we need to add Financial Price Series to the Series collection of the Data Chart control. Note that ItemsSource property on the series is also set to context binding of the chart. In addition, this series has XAxis property set to Category X-Axis and YAxis property set to Numeric Y-Axis that we created in previous step. By default, Financial Price Series requires four data column in order to render Open, High, Low, and Close values of financial candle stick.

        < ig:XFDataChart.Series >

            < ig:FinancialPriceSeries ItemsSource="{Binding}"

                                     DisplayType="Candlestick"

                                     XAxis="{x:Reference xAxis}"

                                     YAxis="{x:Reference yAxis}"

                                     HighMemberPath="High" LowMemberPath="Low"

                                     OpenMemberPath="Open" CloseMemberPath="Close" >

            < /ig:FinancialPriceSeries >

        < /ig:XFDataChart.Series >

The next step is to set the data source on the Binding Context property of Data Chart:

< ig:XFDataChart.BindingContext >

            < local:FinancialDataList x:Name="DataSource" />

        < /ig:XFDataChart.BindingContext >

 

Now, we need to implement our data source for the Data Chart. I have already created a  data source by implementing two class models. The Financial Data Item class represents single item of financial data and the Financial Data List class represents a list of financial data item that have randomly generated values for stock volume and stock prices.

In order to explain how data binding works in the Data Chart control, I created a class diagram. So we have Financial Data Item class with 6 data columns (5 numeric for stock values and 1 string data column for storing date values). The Financial Data List implements IEnumerable interface and that is the key to map the ItemsSource of CategoryXAxis and Financial Price series. Both of these ItemsSource properties are of type IEnumerable so any class that implements this interface and contain data items can be mapped to Data Chart.

Note that each series should have appropriate data mappings. In this case, Financial Price series requires four numeric data columns for Open, High, Low, and Close. In addition, CategoryXAxis must have one data column mapped for the axis labels.

At this point, we can run this application and for simplicity reason, I am going to build and run only the Windows Phone application. In a few seconds, the Windows Phone emulator will load our application... Here we have the Infragistics Data Chart with Financial Price series. On horizontal axis, we have CategoryXAxis with labels mapped to dates and on vertical axis, we have NumericYAxis with values corresponding to Open, High, Low, and Close values of financial data.

So there you go, a simple app demonstrating how to create and bind financial data to Data Chart controls. You can download the source code of this sample here to check it out for yourself. Thank you for watching!


UXify 2015: The Future of UX Design

$
0
0

I usually write blogs with an eye toward how I see our profession progressing so this one will be a bit different. For the past 2 years, the UX Design organization here at Infragistics has hosted a local conference associated with World IA Day (held each year in February). February in NJ has never worked well for us and, after having to reschedule both of those events due to snow storms, we decided to create our own professional conference, UXify, and hold it in the spring.

Our third annual user experience event, UXify 2015, brings together the community of academics, practitioners, technologists, and business leaders for a conversation about the future of applied design, UX, content strategy and development. I hope you’ll join us for an afternoon (lunch included!) of forward-looking talks relevant to the future of User Experience Design.

Where
Infragistics Corporate Headquarters
2 Commerce Dr
South Brunswick Township, NJ 08512

When
Saturday April 11, 2015
Noon – 5PM

Cost
FREE

Eventbrite - UXify NJ 2015 - The Future of Design

UXify 2015 Schedule

12:00 – 12:30

Welcome Remarks and Lunch

12:30 – 1:00

Living at the Intersection of Art and Science: The Future Skills of a Designer
Kent Eisenhuth, Interaction Designer @ Google

1:00 – 1:30

Wearable for Work: Technology, Applications, & Design
Sam Zheng, Senior Consultant, Siemens

1:30 – 2:00

Managing Design Projects: A PM View
Justin Fraser, Senior Project Manager, Infragistics

2:00 – 2:30

UX Competencies in Capital Markets
Sunita Vaswani, Director, UX, Deutsche Bank

2:30 – 3:00

Snack Break

3:00 – 3:30

Universal Design:  One for all, All for one!
John Chin, Experience Strategist, Verizon Wireless

3:30 – 4:00

Content Strategy and the Project Lifecycle
Clare Cotugno, Director of Content Strategy, EPAM Empathy Lab

4:00 – 4:30

Journey Mapping
Ronnie Battista, Practice Lead, Experience Strategy + Design, Slalom Consulting

4:30 – 5:00

Surviving the Demise of Architecture: Get Strategic, Get Coding, or Get out of the Way
Lisa Woodley, Vice President, Experience Design, NTT DATA

5:00 – 5:15

Closing Remarks

Eventbrite - UXify NJ 2015 - The Future of Design

What’s new in Microsoft .NET Framework 4.6?

$
0
0

 

The .NET Framework was been taking up a fair amount of time in the tech press in recent months, mainly due to Microsoft's bold move to open source much of the technology. One announcement you may have missed was the release back in November of a preview version of .NET 4.6. In this post we take a look at what you can expect.

The .NET Framework

The .NET Framework is a development platform for building apps for Windows, Windows Phone, Windows Server, and Microsoft Azure. It consists of the common language runtime (CLR) and the .NET Framework class library, which includes classes, interfaces, and value types that support an extensive range of technologies.

The most recent official release of .NET was 4.5.2. Version 4.6 is currently only in preview, so what’s new?

What’s new in version 4.6?

When you install .NET 4.6 Preview it will actually be installed as .NET, partly to maintain (in-place) compatibility with previous versions (4, 4.5, 4.5.1 and 4.5.2). This means that if you have one of the above mentioned frameworks installed on your computer, this installer will upgrade them to 4.6 while if you have older frameworks installed like 3.5, 2.0, 1.1 etc., then it will run alongside them.

Important note: Before downloading and installing this preview version, please remember that Visual Studio 2015 Preview and .NET 4.6 Preview are for testing and feedback purposes only and not for a production environment.

There are three key areas to look at:

  1. Open Source .Net Framework Packages
  2. Support for Code page encodings
  3. Improvements to event tracing

1. Open Source .Net Framework Packages

.NET Core 5 is a modern, componentized framework that ships via NuGet. That means you can ship a private version of the .NET Core Framework with your app. Other apps' versions can't change your app's behavior.

.NET Core CLR is built for Windows, Mac and Linux and it will be both open source and it will be supported by Microsoft. Some of the .NET packages like Immutable collections and SIMD APIs are available on GitHub. All these packages are licensed under the MIT license. Microsoft are also open sourcing RyuJit and .NET GC, and making them both cross-platform.

There is a new free SKU for Visual Studio for open source developers and students called Visual Studio Community. which supports extensions. The following new collection classes have been introduced.

  • System.Collections.ObjectModel.ReadOnlyCollection
  • System.Collections.Generic.Queue
  • System.Collections.Generic.Stack

Some new cryptography APIs have also been introduced — these include the following:

  • SymmetricAlgorithm.KeyExchangeAlgorithm
  • AsymmetricAlgorithm.SignatureAlgorithm
  • System.Security.Cryptography.X509Certificates.X509Certificate

GitHub contains the foundation libraries that make up the .NET Core development stack:

  • Share a collection in such a way that its consumer can be assured it will never change.
  • Provide implicit thread safety in multi-threaded applications. No locks required to access collections.
  • Follow functional programming practices.
  • Modify a collection during enumeration, while ensuring that the original collection does not change.

How are these things helpful?

Having the .NET framework Packages open source is very useful for developers who will benefit from a fully supported, fully open source, fully cross platform stack for creating server and cloud applications. It will allow the .NET teams in Microsoft to collaborate even more effectively with other developers around the world. 

2. Support for code page encodings

.NET Core primarily supports Unicode encodings, and by default it provides limited support for code page encodings. You can add support for code page encodings that are available in the .NET Framework but unsupported in .NET Core by registering code page encodings with the Encoding.RegisterProvider method. We need to use the namespace:

System.Text.CodePagesEncodingProvider


So to make these code pages available to .NET 4.6 you can use these additional code pages:

  • Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.
  • Retrieve a CodePagesEncodingProvider object from the static Instance property.
  • Pass the CodePagesEncodingProvider object to the Encoding.RegisterProvider method. 

 

The .NET Framework for the Windows Desktop supports a large set of Unicode and code page encodings. .NET Framework 4.6 Preview supports only the following encodings:

  • ASCII (code page 20127)
  • ISO-8859-1 (code page 28591)
  • UTF-7 (code page 65000)
  • UTF-8 (code page 65001)
  • UTF-16 and UTF-16LE (code page 1200)
  • UTF-16BE (code page 1201)
  • UTF-32 and UTF-32LE (code page 12000)
  • UTF-32BE (code page 12001)

How are these things helpful?

The most common problems in encoding operations occur when a Unicode character cannot be mapped to a particular code page encoding. The most common problems in decoding operations occur when invalid byte sequences cannot be translated into valid Unicode characters. With new support for code page encodings, developers do not have to worry about the fallback strategy for an object encoding to be used.

3. Improvements to event tracing

An EventSource object can now be constructed directly, and you can call one of the Write() methods to emit a self-describing event

EventSource provides channel support and some of the event source validation rules have been relaxed. This means:

  • EventSource types may now implement interfaces. This enables the use of event source types in advanced logging systems that use interfaces to define a common logging target.
  • The concept of a utility event source type has been introduced. This feature enables sharing code across multiple event source types in a project to enable scenarios such as optimized WriteEvent overloads.

 

using System.Diagnostics.Tracing 

//Assembly: mscorlib (in mscorlib.dll) 

 

public void Write( 

string eventName, 

T data 

)  

 

In the above code, <T> is the type that defines the event and its associated data. This type must be an anonymous type or marked with the EventSourceAttribute attribute, eventName is the name of event and data is the object of type .

How are these things helpful?

The .NET Framework 4.6 enables out-of-process, Event Tracing for Windows (ETW)-based activity tracing for a larger surface area. This enables Advanced Power Management (APM) vendors to provide lightweight tools that accurately track the costs of individual requests and activities that cross threads. These events are raised only when ETW controllers enable them; therefore, the changes don't affect previously written ETW code or code that runs with ETW disabled. Hence increasing the performance of an application effectively.

.NET’s Future, today

Microsoft is now combining all of the various next-gen .NET components under a single umbrella. That includes .NET 4.6, the next update to the desktop .NET framework, which includes a number of tweaks to the Windows Presentation Foundation (WPF) subsystem. Also included is ASP.Net v5, which has been extensively re-engineered to be more modular for a ‘cloud first’ world. Other components are included with various versions numbering, with .NET 2015 as the overarching banner for this set of releases.

One big benefit of this new versioning scheme is that development of .NET will be able to proceed at a faster pace, particularly as it moves toward its open source future.

News round up for the week - .NET, JQuery, HTML

$
0
0

We live in an era of information overload. At no other time in human history have we received communication and messages on anywhere near the current level. Our cell phones are constantly with us; colleagues, friends and family email, call and text us all the time. The Internet - where many of us spend our days working - is saturated with articles and content screaming “read me!”, advertisements and distraction. And that’s not without taking into account ‘traditional’ information - from billboards to newspapers, television, radio and beyond.

While this can all be a little overbearing, it’s undeniably useful to be able to find out whatever we want at the touch of a button or the tap of a screen. However, sifting out what is and isn't useful to us, hunting information down and analyzing it is time consuming. In our hyper-busy lives, keeping up to date with information relevant to our work - developments in .NET, jQuery and HTML - is hardly at the top of most developers’ to-do lists. Nonetheless, having a good idea of what’s going in our field is a ‘must’ for anyone wanting to stay at the top of their game.

 

In this week’s news round up we’ll save you the time spent hunting this information out. Major recent events in .NET include Microsoft’s continued open sourcing of parts of the framework; in the jQuery world Esprima 2.1.0 has just been released while in HTML land we’ve seen Google take further steps to banish Adobe’s Flash player to the history books. Read on for more.

.NET CoreCLR open sourcing doesn’t look like closing

It was a big deal when Microsoft announced they’d be open sourcing CoreCLR, representing a real change in direction for the corporation’s strategy. Since then GitHub has been a veritable hive of activity, with many updates, new features and builds. Given all this activity, it’s no surprise that some members of the community have been asking for a more visible and transparent view of what the Microsoft team are doing with CoreCLR. Naturally no one wants to spend hours working on some solution or another only to find Microsoft have already been working on it. Microsoft are aware of this and have begun publishing issues and information on work they’re carrying out on a publicly visible branch. You can get up to date with issues here, otherwise keep an eye on the blog - they plan on making all this easier to follow soon.

Otherwise, there’ve been some important improvements on support for CoreCLR on Linux and Mac OS X. For more information on Microsoft’s current and future open sourcing schedule, see here.

What does this mean for you?

Microsoft are showing a real willingness to listen to the community, react to their requests and work together going forward. If you want to get involved, this is a great time to participate in work which could have real long term impacts.

JQuery: parser update released

Looking for news in the world of jQuery? The release of Esprima 2.1.0. Esprima is an impressive parser and this update introduces support for various pieces of ES6 syntax. The folks at jQuery have also modified Esprima’s testing infrastructure and have collaborated with other JavaScript parsers to help define community standards. Looking forward, a 2.2 version of the parser will be released in the coming weeks. In the meantime, version 2.1.0’s release note includes:

 

  • Support ES6 class #1001
  • Support ES6 rest parameter #1011
  • Support ES6 computed property name #1037
  • Support ES6 lexical declaration #1065
  • Expand the location of property getter, setter, and methods #1029
  • Enable TryStatement transition to a single handler #1031
  • Tolerate unclosed block comment #1041

 

What does this mean for you?

Fundamentally, Esprima is just going to make things faster and easier when you use jQuery - and who wouldn’t want that?

HTML5 - the unstoppable rise

Google have thrown their full weight behind HTML5 at the expense of Adobe Flash. That’s nothing new, but Flash’s coffin had another nail knocked in when Google confirmed that they would automatically convert all ads containing flash into HTML5. This basically means advertisers will be able to make ads which target audiences even more consistently (and contribute to their information overload!). On a larger scale this brings us closer to the day when all media on the web will come directly in HTML5.

What does this mean for you?

If you haven’t already stopped using Flash, put it at the top of your ‘to-do’ list!

That’s all folks

Over the coming days we’ll be scanning the forums, blogs and gossip sites to bring together all the freshest news in .NET, jQuery and HTML5 so you don’t have to. Leave your thoughts in the comments section below, and we look forward to catching up with you next time.

DevWeek 2015

$
0
0

I ran out of time to blog about this before the event, but hey, I went to DevWeek 2015 in London, UK last week. It's the largest developer conference in the UK and I gave two presentations - one about the width of UX and the other more focused on visual design best practices and principles.

Compared to the last years, the number of UX presentations has increased and those sessions have been well filled. This shows to me that the interest of developers for that topic is growing. As the expectations towards the UX of products increase throughout the markets but at the same time there are not enough UX professionals available, developers are required to take care of usability and visual design more than before. But then, I didn't get the impression they would hate to do so, the folks in the UX related sessions were very interested and curious to learn more about UX.

In that vein, I'll be back in London in May to give a talk at Software Design & Development and in Nuremberg, Germany, in June for a talk at Developer Week.

 Conference logo

 

How to gather 'User Interface' requirements from stakeholders

$
0
0

Gathering UI requirements is simple right? You just need to ask end users what they want, what they need and from there get on with the business of developing the solution they asked for - whether it’s an app, an Intranet or some other enterprise IT solution. If only things were so simple!

When we go about speaking to stakeholders, as part of our enterprise services, it’s very easy to listen to what one or two stakeholders tell us, write it down in a report then get on with the business of designing the solution. The problem with this approach is that the people gathering requirements and the stakeholders in a company often have very different understandings of what their project needs and what different terms used mean. A company director might say “we want our staff to have a mobile app which feels like our CRM”. The person gathering requirements might assume this means they want an app which has the same navigation system, when the company director meant something which has the same ‘look’.

It might never be possible to provide exactly what users want, time and money often get in the way, but gathering User Interface requirements from stakeholders fundamentally requires designers to “walk a mile in the shoes” of end users. It’s about having more than a superficial idea of what CTOs want. It is about getting a deep understanding of how a whole range of users - from the shop floor to the boardroom - navigate, understand and explore the system.

This isn’t something you can do in an afternoon, it might take weeks (or even months) before you fully understand how users talk about their IT needs, what vocabulary they use to describe certain actions (these might be technically incorrect but make sense to end users) and how they navigate through pages.

How can we avoid misinterpreting one another?

There’s a tendency when gathering requirements to treat it as a box ticking activity, but to really ensure your UI gathering is effective, it’s important to do some research. There’s a whole range of methods you can put into practice to find out about UI requirements, and when this is done effectively, you’ll feel a lot more confident that your final build will not only please end users, but will also do much more than they originally thought they wanted.

 1.    Understand the current state of play: Whether you’re building a UI from scratch, or are improving on a current system, it’s important to get a deep understanding of how the company works, what they do and what the system you’re building for them does.

2.    Test your assumptions: ask lots of questions, then ask some more, and after that, keep on asking. Don’t just ask a select few people - IT managers and CEOs - speak to employees throughout the organization, from top to bottom and find out everything you can about how they work and what they need. You need ask questions covering:

 a.    Why do users interact with the solution in the way they do - is something restricting them? Are they confused or lost? Could it be improved?

b.    Where do they interact with the system? Is it on the shop floor, in a back office, front of house, in the car, on a mobile or a tablet or a plain old desktop?

c.    Who interacts with the system and in what way do different people interact with it?

d.    How do they interact? You need to ask about their problems; where they get lost while navigating; do they always follow the same pathways or do they visit lots of pages?

e.    What are their problems and issues, and what do they want and need?

3.    Carry out research and document your results. There are many different methods and each one is more or less relevant to different situations. The most important thing to do is to find ways of storing all the information you’ve gathered and it’s worth recording interviews and mapping user journeys in order to really understand their pathways.

4.    Present your results and explain your suggestions for UI design. As for feedback.

5.    Once everything has been signed off, you can’t sit back on your laurels; effective UI design means you need to keep clients involved throughout the development stage (as irritating as this sometimes can be!). They will typically be investing considerable resources into your developments, so you don’t want to build something which doesn’t actually suit their needs.

The best UI resources

At Infragistics we understand that gathering UI requirements is never a simple process. However, our range of UI Controls and productivity tools (as well as our own consulting services) allow teams to storyboard UI navigation and ultimately build a set of stunning designs. UI requirement gathering is far from simple, but carrying out effective research means you can be confident your builds are the best they can be.

Developer News - What's IN with the Infragistics Community? (3/30-4/5)

$
0
0

Curious about what 30 tech skills can get you a $110k and above salary? One of our top Developer News articles this week can give you insight into what they are!

5. How Steve Jobs Trained His Own Brain (Inc.)

4. 30 Tech Skills That Will Get You A $100,000-plus Salary (VentureBeat)

3. DevOps is Bullsh*t: Why One Programmer Doesn't Do It Anymore (jjmojojjmojo)

2. Machine Learning: Full-Text Search in Javascript (Part 1: Relevance Scoring) (Burak Kanber)

1. The Simple, Elegant Algorithm That Makes Google Maps Possible (Motherboard)

Area Judgements: Areal Problem

$
0
0

Research suggests we aren't very good at judging areas. We're much better at judging lengths and position. I've already touched on this before when discussing whether to choose a pie chart or a bar chart, but area judgements are also required in other popular visualization formats. If we want to be effective at communicating data through visualizations we should favor encodings that require length or position judgements. Hence we should reject the proportional circles on the left in favour of the bars on the right (or something similar like a dot plot).

If that was all there was to it then this would be a very short article. But there are other reasons one might choose to use area. In his book Information Visualization, Colin Ware suggests use of area in place of length when there is a large difference in size between the largest and smallest values that require encoding. (For example, most of the spices above retail in the UK at a few pence per gram. Saffron, on the other hand, costs ~£5-15 per gram!) The use of a second dimension means smaller values can be seen and magnitudes distinguished without the need for a very large screen or piece of paper. Large magnitude differences are often displayed using logarithmic scales or transformations. This, however, may not be appropriate for a general audience.

A different (probably more common) use of area encoding is in data-map making. In this case position is already being put to use to show geographic features and locations. In the example below, the center of each circle marks the location of the stadium of a Barclays Premier League soccer team while the area of each circle is proportional to the capacity of the stadium (as given in the official Premier League Handbook).

As an alternative to "patch maps" (now frequently termed choropleth maps), Cleveland and McGill suggest the use of "framed rectangles" for encoding values on maps. These are individual bars encased in their own outer rectangle that provides a fixed reference for (theoretically) easier comparison. The perceptual task in decoding the data is then length measurement or relative position along non-aligned scales. In principle this could also work as an alternative to the proportional circles used above. The map below, using the same data as the map above, illustrates this option.

How do the two methods compare? Firstly I think it's intuitive that the center of a circle represents a location. In the framed-rectangle version it is the center of the base of the frame that marks the location; this is probably less obvious. A much bigger issue for the framed-rectangle map is what happens when points overlap. This is most problematic in London, where six clubs are based. With circles we can distinguish between the grounds despite the overlapping; we can, for example, see that one stadium (Arsenal's) is noticeably bigger than the other five. In the framed-rectangle map not even the number of stadiums in London is clear. This alone makes it a poor choice in this particular instance. Where data points are more dispersed and/or more evenly distributed this may not necessarily be the case.

Of course if your main interest is to communicate stadium capacities and not locations then a simple bar chart or dot plot would (again) be appropriate.

This last point can be generalised: don't automatically assume a data map is the best choice of visualization for your data just because it contains geographical aspects. Hans Rosling's famous TED talk of February 2006 highlights this wonderfully. While his talk centers around political geography, his main visualization tool is not a map but a bubble plot (aka a bubble chart). He still uses area (and indeed color) to encode data, but by eschewing longitude and latitude he's able to use horizontal and vertical position to show more information about his topic of concern - global development. (Gapminder World allows you to interactively explore the data he discusses at your own leisure.)

So bubble plots represent another type of visualization where use of area encoding helps to convey a message. This doesn't change the fact that we're better at judging position than we are at judging area, so if you go down the bubble plot route then use the horizontal and vertical scales for the most important variables in the dataset. This may, of course, depend on what information it is critical to convey at any given time and thus may be different for different publications or presentations or even separate slides in the same presentation.


Are You Changing the Rules of the Road?

$
0
0

I'm a regular jogger, but due to my travel schedule over the last six months, I'm no longer a member of a gym. That works out fine about 9 months of the year and whenever I'm staying in hotels, but if I'm at home during the winter, it gets a little brutal. That's why I've been out running like Forrest Gump this past week since the weather broke in Chicago and we've seen spring-like conditions all week. My favorite destination when I'm home is a small, nearby lake called Lake Arlington that is surrounded by a nice trail and thus a popular destination for walkers, joggers, and bikers.

The trail is quite uniform and there is a solid yellow line in the middle of it with room enough for two people walking side by side to be on each side of the yellow line. So, it's like a 4 lane road for people. Not surprisingly, people have historically behaved, by and large, as if they were on a road, with everyone usually on their right side and moving to the left to pass, when necessary. That all changed when there was a tragic accident a couple of years back, apparently.

I wasn't aware of the accident when it happened, but I do recall that last year when I came out for the first time to run, there were a lot of signs next to the trail and painted on the ground that changed the way things worked. Now, all bicycles and roller-blade traffic are supposed to go in the outer lane and all foot traffic in the inner lane. It seemed an odd change to me, but I do my best to remember where I'm supposed to be. Truth be told, though, I just accomplish this by always running around the lake in the same direction -- the direction that results in me being on the right side of the trail.

The other day, I was running out there, and I saw someone running at me in the opposite direction in the other lane (i.e. the 'wrong' lane which, confusingly, was her right lane). A lot of people probably don't bother to read signs on the pavement when they're walking or jogging, so she was probably just doing what she'd do anywhere else and following the common convention. A bicyclist coming up behind her was ringing the bell on her bike angrily, inasmuch as a chirping bicycle bell can be called angry. She was wasting her effort, however, because the jogger had headphones in. When she passed the jogger, she continued ringing the bell angrily while turning around and gesturing at the lane markers on the ground. I understood what she was getting at; the other jogger probably just thought that she was a lunatic.

Jogging, while refreshing, is extremely boring, so I spent the next 15 minutes or so contemplating this exchange and thinking about how it relates to my life and the world of programming. Was the unusual reconfiguration of the lanes a good choice? It's entirely possible that a far better urban planning mind than mine went to work on how to structure things following this accident. It's also possible that they changed things just for the sake of change to give a grieving widower some comfort. But whether or not it's a good idea, it's confusing because it runs completely counter to an established convention. What I couldn't convince myself to agree with was the anger directed at the jogger, since anyone new to the lake is setup to get it wrong by default.

What I realized is that the parallel thing that I talk about and coach people on in the programming world is the "Principle of Least Surprise." This is the idea that, all else being equal, system designers should aim to minimize the users' learning curve by incorporating patterns that they already understand. To drive the point home, consider a counter-example. Imagine if I designed a web application where left-clicking on buttons did nothing, and only right-clicking allowed you to activate the buttons. Would you be any less enraged and frustrated (or at least confused) at this web app if I told you afterward that my way actually made a lot more sense or, even, that it was done in response to some kind of problem or tragedy?

This holds true in and around software, and it holds true now more than it ever has before. Users don't expect to read instruction manuals -- they expect the things they're using to be discoverable. This is true whether they're using an application you've written or whether they're hacking through your API with Intellisense. This doesn't mean that you can't introduce new usage paradigms, but it does mean that you have to be clever and deliberate when doing so, in order to bring them along. There is an implied expectation from your users that you will delight them while not confusing them, even if not confusing them means compromising on what you believe the optimal solution to be (at least at first).

So when building applications or APIs, think of your users. When they fire up your app or call that first method on the code base, do you want their instincts to put them immediately in the correct jogging lane, or do you want them to be befuddled by random people shaking fists at them? Your urban plan may be the most safe, state of the art, wonderful thing ever conceived, but all of the joggers are going to head for the lakes where they understand how things work and no one yells at them.

This is guest blog post by Erik Dietrich. Erik is the founder of DaedTech LLC, also an experienced programmer, software architect, team leader, coach, and technologist that enjoys working with a wide variety of programming languages, frameworks and tools. The majority of his recent experience has focused on the .NET framework, though over the years he has worked with C++, Java, and a number of other languages. Projects range from low-level driver and kernel module programming all the way up to user interface design, and the types of applications run the gamut from home automation to rigorous code analysis to line of business applications.

Editing SharePoint files with your smartphone and tablet devices on the go

$
0
0

In the past, the vast majority of businesses were centralized with smaller branch offices spread around the country or world. While this management model has not been fully replaced, a global trend towards remote and distance working is undeniable.

Mobile and distant working began with the Enterprise IT revolution in the 1970s. Cellular phones later allowed employees to be contacted anywhere, email pushed this communication to new heights, and then laptops meant the office could literally be anywhere.

The most recent step in this evolution has been the introduction of smartphones and tablet devices. The beauty of these machines is that they permit contact and collaboration anytime, anywhere. Often more effective during sales pitches and easier to interact with than laptops, tablets in particular are becoming a must-have for the distance worker. In 2015 over  320 million are expected to be shipped.

As great as tablets are, they’re also less powerful than laptops and have reduced functionality when it comes to multitasking. Furthermore, until recently, tablets and mobile devices only offered limited access to Microsoft’s SharePoint. Given SharePoint’s dominance in the Enterprise IT field, there’s been a real need to configure it to devices and allow distance editing. SharePlus from Infragistics responds to this need. 

How SharePlus lets you edit on the go

SharePlus offers a unique platform for colleagues to access and work with their company’s SharePoint solution from both iOS and Android tablets. Although there is some native functionality with SharePoint on tablets, SharePlus offers much more when it comes to working with, editing and operating your company’s Intranet. In addition to its impressive security, access to most parts of your in-house SharePoint and integration with all major features of the desktop UI, SharePlus is particularly strong when it comes to editing documents.

There are numerous reasons a knowledge worker would wish to edit documents on the go – be it online or offline:

  • Sales people may need to create last-minute annotations to PDF proposals before meetings with prospects;
  • Managers want to access and comment on the latest business intelligence reports;
  • Colleagues caught in traffic or travelling internationally don’t want any possible lack of connectivity to get in the way of work;
  • Colleagues in the field visiting sites will want to instantly share their thoughts and information retrieved from their research into spreadsheets and documents.

Easily edit documents offline and online

Editing and collaborating on documents couldn’t be easier with SharePlus and users will find they essentially have the same functionality as on the desktop version in just a few taps and swipes. Whether it’s editing the actual content of a file or editing its metadata, status or versioning, you really can do everything you’d do with SharePoint on more traditional platforms.Edit Documents with SharePlus on the Go

Editing item properties is child’s play. Users need simply highlight a file, tap Action | Edit Properties and make the changes they require. These can be instantly saved, either directly to the server or as a draft and the user’s location can be added too. Including smooth integration with third party document-editing Apps, SharePlus really simplifies collaboration. In addition to MS Office applications, SharePlus also permits your contribution to PDF files without users ever having to leave the UI.

While “real time” editing is great for collaboration, it’s not always possible. Fortunately, SharePlus includes an offline mode and this means users can work on documents on flights or in remote regions. SharePlus essentially checks the document out, and when the user is back in range of signal can sync again with their server and view how their changes correspond to those of their colleagues.

Long distance relationships can work!

Many aspects of office work have been disrupted, changed and improved through the integration of ever more powerful Enterprise IT solutions. As discussed above, the modern workforce is ever more agile, mobile and open to opportunities and changes. This is undeniably an exciting place for businesses to be.

However, for all the positives of distance working, it can disrupt the importance of real-time collaboration and face to face interaction that businesses rely on. SharePlus offers a solution to mitigate these issues and allow collaboration from any device, anywhere, any time. As long as businesses need people to work together, share ideas and develop new concepts, there will always be a need to find tools to permit their doing so.

SharePlus for SharePoint - Download for iOS

App Development using the Office 365 API – Part 2

$
0
0

In one of my previous blog posts, I introduced the Office 365 platform and covered some of the features that the Office 365 API provides for developers. In this blog post, let us explore how to use the Office 365 API from a Windows Store App.

We’ll use the Calendar API as an example and demonstrate in step by step approach on how to add an event from the Windows Store App as well as list all the events from your Office 365 Data.

Let’s see how to use the Calendar API that is available in Office 365.

  1. Check if all the prerequisites are met or installed as per App Development using the Office 365 API – Part 1.
  2. If Visual Studio 2013 is installed, you can install Office Developer Tools for Visual Studio 2013 from here.
  3. Create a new Windows Store (8.1) project in Visual Studio. If you have an existing store project, open it in Visual Studio.

4. You need to install the NuGet package Azure Active Directory Authentication Library to the project. This library provides you with some of the easiest ways to authenticate users with the Microsoft Azure Active Directory. To add this Nuget Package, Right click on the Visual Studio Solution and click “Manage Nuget Package”.

In the Manage NuGet packages Dialog, select online option in the left sidebar and then search for the Azure Active Directory Authentication Library and install it.

5. To use the Calendar API, we need to add the connected services (Office 365) and enable permissions on the Calender for the Windows Store App.

Right click on the project file in Visual Studio and select “Add -> Connected Service”.

In the Service Manager, login to your Office 365 account to register the app and set the permissions for the various API. In this sample, let’s select “Calendar”.

In the Calendar Permissions, select “Read users calendars” and “Have full access to user’s calendars”. And click Apply.

6. Build the Project. This will add the dependent assemblies that are necessary to perform various operations in the Calendar in Office 365 from your Windows Store App.

7. In your Windows Store Project, create a new class with the name “Office365Helper” and add the below data members:

publicstaticreadonlystring DiscoveryResourceId = "https://api.office.com/discovery/";

publicconststring Authority = "https://login.windows.net/common";

publicstaticreadonlyUri DiscoveryServiceEndpointUri = newUri("https://api.office.com/discovery/v1.0/me/");

publicstaticAuthenticationContext _authenticationContext = null;

publicconststring ClientID = "91873825-c6e8-42a9-b6de-40c6f98a851d";

publicstaticUri _returnUri = newUri("http://App4");


Note the ClientID and the return Uri. This would change for each application. You can get these properties by registering your application in the Azure Active Directory.

To register your application in your Microsoft Azure active directory, visit http://azure.microsoft.com/en-us/ and login with your Office 365 credentials.

Navigate to the Active Directory section in your azure account and select the active directory name.

Select the Applications tab and click the “Add” button from the bottom of the screen.

Follow the steps that are shown in the wizard screen where you can register your app.

Once your app is registered, navigate to the “configure” section of your app and copy the ClientID and the return Uri of the app. You need to include it in the respective member of your Office365Helper class.

privatestaticasyncTask<string> GetTokenHelperAsync(AuthenticationContext context, string resourceId)

        {

            string accessToken = null;

            AuthenticationResult result = null;

            result = await context.AcquireTokenAsync(resourceId, ClientID, _returnUri);

            accessToken = result.AccessToken;

            return accessToken;

        }

8. You should authenticate your user with the Azure AD and retrieve the Access Token. Add the below method to your Office365Helper class.

The above method uses the Azure Active Directory Authentication Library to get the access token.

9. The next step is to use the DiscoveryClient to find the service end points. Once the service end points are found, the capability needs to be identified. This can be a Mail capability or Calendar capability, but in this example, it is the Calendar capability. The parameter called capability is used with in the below method so that the same can be used either for the mail or Calendar. Add the below method to the Office365Helper class.

publicstaticasyncTask<OutlookServicesClient> GetOutlookServicesClient(string Capability)

        {

            _authenticationContext = newAuthenticationContext(Authority);

 

            DiscoveryClient discoveryClient = newDiscoveryClient(

            async () => await GetTokenHelperAsync(_authenticationContext, DiscoveryResourceId));

            CapabilityDiscoveryResult result = await discoveryClient.DiscoverCapabilityAsync(Capability);

            var outlookClient = newOutlookServicesClient(

                result.ServiceEndpointUri,

                async () => await GetTokenHelperAsync(_authenticationContext, result.ServiceResourceId));

            return outlookClient;

        }

10. The GetOutlookServicesClient method return the OutlookServicesClient object which can be used to get the list of events or add an event to the Office365.

11. Now, let’s build the UI to list and add the Office 365 functionality within your app. Add the below XAML code snippet under the Page element.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

        <Grid.ColumnDefinitions>

            <ColumnDefinition Width="637*" />

            <ColumnDefinition Width="729*" />

        Grid.ColumnDefinitions>

        <Grid.RowDefinitions>

            <RowDefinition Height="41*" />

            <RowDefinition Height="343*" />

        Grid.RowDefinitions>

        <TextBlock Grid.Row="0" Text="Calender App" Style="{StaticResource HeaderTextBlockStyle}" Grid.ColumnSpan="2" >TextBlock>

        <Button Name="btnLogin" Grid.Column="1" Content="Login" Width="150" HorizontalAlignment="Right" Click="btnLogin_Click">Button>

        <Grid Grid.Row="1" Grid.ColumnSpan="2">

            <Grid.ColumnDefinitions>

                <ColumnDefinition Width="637*" />

                <ColumnDefinition Width="729*" />

            Grid.ColumnDefinitions>

            <StackPanel>

                <TextBlock Text="Attendee Email" Style="{StaticResource SubheaderTextBlockStyle}" Margin="5,5,5,5">TextBlock>

                <TextBox Name="txtEmail">TextBox>

                <TextBlock Text="Subject" Style="{StaticResource SubheaderTextBlockStyle}" Margin="5,5,5,5">TextBlock>

                <TextBox Name="txtSubject">TextBox>

                <TextBlock Text="Location" Style="{StaticResource SubheaderTextBlockStyle}" Margin="5,5,5,5">TextBlock>

                <TextBox Name="txtLocation">TextBox>

                <TextBlock Text="Content" Style="{StaticResource SubheaderTextBlockStyle}" Margin="5,5,5,5">TextBlock>

                <TextBox Name="txtContent" Height="122" >TextBox>

 

                <Button Name="btnAdd" Click="btnAdd_Click" Width="200">Add DadaButton>

            StackPanel>

            <ListBox Name="LstEvents" Grid.Column="1" Margin="28,25,27,30">ListBox>

        Grid>

Grid>

12. In the code behind, add the data member of type OutlookServicesClient for the page.

privateOutlookServicesClient _outlookClient;

 13. Add the below code snippet to the code behind.

privateasyncvoid btnAdd_Click(object sender, RoutedEventArgs e)

        {

            if (_outlookClient != null)

            {

                // Initialize the attendees

                Attendee[] attendees =

                {

                        newAttendee

                        {

                            EmailAddress = newEmailAddress

                            {

                                Address = "test@developerpublish.com"

                            },

                        },

                };

                // Create an instance of the Event

                Event newEvent = newEvent

                {

                    Subject = txtSubject.Text,

                    Location = newLocation { DisplayName = txtLocation.Text },

                    Attendees = attendees,

                    Start = newDateTimeOffset(newDateTime(2015, 04, 1, 9, 30, 0)),

                    End = newDateTimeOffset(newDateTime(2015, 04, 1, 10, 0, 0)),

                    Body = newItemBody { Content = txtContent.Text }

                };

                // Add the event to the default calendar

                await _outlookClient.Me.Events.AddEventAsync(newEvent);

            }

            LoadCalenderData();

        }

 

        privateasyncvoid LoadCalenderData()

        {

            if (_outlookClient != null)

            {

                // Get the events and display it in the list box.

                var events = await _outlookClient.Me.Events

                            .Take(10)

                            .ExecuteAsync();

                LstEvents.Items.Clear();

                foreach (var calendarEvent in events.CurrentPage)

                {

                    LstEvents.Items.Add(calendarEvent.Subject);

                }

            }

        }

 

        privateasyncvoid btnLogin_Click(object sender, RoutedEventArgs e)

        {

            _outlookClient = awaitOffice365Helper.GetOutlookServicesClient("Calendar");

            LoadCalenderData();

        }

14. Examining the above code snippet, we can get the list of events from Office 365, as shown below.

_outlookClient = awaitOffice365Helper.GetOutlookServicesClient("Calendar");

var events = await _outlookClient.Me.Events

                            .Take(10)

                     .ExecuteAsync();

15. Similarly, to add a new event to Office 365, we can use the Events.AddEventAsync method by passing the Event object.

Event newEvent = newEvent

                {

                    Subject = “DeveloperPublish.com event”,

                    Location = newLocation { DisplayName = “Infragistics Office” },

                    Attendees = ,

                    Start = newDateTimeOffset(newDateTime(2015, 04, 1, 9, 30, 0)),

                    End = newDateTimeOffset(newDateTime(2015, 04, 1, 10, 0, 0)),

                    Body = newItemBody { Content = “ This is a Infragistics log” }

                };

       // Add the event to the default calendar

await _outlookClient.Me.Events.AddEventAsync(newEvent);

16. Run the App. Click the login method to authenticate with your Office 365 credentials. Immediately, you should see the list of events from your Office 365 data as well as the provision to add the new event.

And there you have it!

Building Native Mobile Apps in C# with Xamarin.Forms & Infragistics - Free Webinar!

$
0
0

I just wanted to take a quick moment and bring to top of mind this week's free webinar. Headlining is a guest you're well acquainted with, our own SVP of Developer Tools, Jason Beres. This month is bound to be exceptional, because Jason will be joined by Xamarin's Technical Developer Evangelist, Michael James! Together, Jason and Michael will walk you step by step through building native mobile apps with a single codebase, all in the comfort of Visual Studio. You'll see how they implement data access controls, grids, charts, and a few other surprises too! By the time the webinar wraps, you'll have all the skills you need to get started on your next mobile application.

So what are you waiting for?

The webinar is on Thursday, April 9th at 11am EST/8am PST, and space is limited, so register now!

A newbies guide to Windows Presentation Foundation

$
0
0

Windows Presentation Foundation (WPF) is a Microsoft technology that was initially released as part of the .NET Framework 3.0. Previously known as "Avalon", WPF is used as a presentation system for building Windows client applications with a rich user experience. With WPF, developers can create a wide range of both standalone and browser hosted applications.

While it is useful, it is not universally known in the development community. In this post we will therefore look in more detail at this technology and understand how it can be valuable for developers.

Get to know WPF

At its core, WPF is a rendering engine that is resolution independent and vector-based. It is built to take advantage of the modern graphics hardware that is available in most business devices nowadays. WPF extends the core with a comprehensive set of application-development features such as:

 

  • Extensible Application Markup Language (XAML)
  • Controls
  • Data binding
  • Layout
  • 2-D and 3-D graphics
  • Animation
  • Styles
  • Templates
  • Documents
  • Media, text, and typography.

 

WPF is included in the Microsoft .NET Framework, so you can build applications that incorporate other elements of the .NET Framework class library.

Developers with an ASP.NET background will feel familiar with the ability to develop an application using markup and code-behind. WPF applications use the Extensible Application Markup Language (XAML) to implement the appearance of an application while using a managed programming language like C# or VB.NET, to implement its behaviour. Usingthis approach brings you the following benefits:

  • Development and application maintenance costs can be reduced, due to the fact the user interface is not tightly coupled with the code-behind.
  • Developers can work simultaneously with designers, because of the separation of the markup and the code.
  • There are multiple tools available for design and application code development such as Microsoft Expression Blend for design and Visual Studio which targets developers.
  • Globalization and localization is simplified.

A number of uses

The foundation of WPF is built on the .NET Framework, the System.Windows library and markup and code-behind. WPF can be used to build 2 types of applications:

Standalone applications

With Standalone applications you can use the System.Windows class library to create windows or dialog boxes with menu bars and toolbars. These applications can use all the other libraries in the .NET Framework too.

Browser-hosted applications

Browser-hosted applications, also known as XAML browser applications, will use the System.Windows.Controls.Page class and functions to create pages that use hyperlinks to navigate. Browser-hosted applications run in the browser, although note that these browser-hosted applications are executed in apartial-trusted security sandbox so they will have some restrictions. The type of restrictions can be compared with the restrictions on HTML-based applications. Still, the majority of WPF features can be safely executed from browser-based applications.

Core elements of WPF

WPF is built to use the rich graphic capabilities of modern devices and includes some core elements to develop extensive, scalable and flexible applications. The set of graphic features have the following benefits:

 

  • They are resolution and device independent. WPF is using a device independent pixel (1/96th of an inch). Each device independent pixel automatically scales to match the dots-per-inch (dpi) setting of the system it renders on it.
  • The WPF coordinate system is measured with double-precision floating-point numbers rather than single-precision.
  • WPF simplifies graphics programming by managing animation scenes for you; there is no need to worry about things like scene processing, rendering loops, or bilinear interpolation.
  • The WPF graphics system takes advantage of graphics hardware to minimize CPU usage on the device that it runs on.

 

WPF contains powerful graphic elements such as 2D and 3D shapes and geometries. These elements can not only be used for drawing but can also be used in an interactive way - such as in buttons. WPF can add 2D effects to elements like gradients, rotation, scaling and the engine can render 3D elements on the screen to build rich user interfaces.

Besides these powerful graphic elements, WPF supports animations like grow, shake, spin or fade to create page transitions or animate the elements in the application.

Best practices

Like with any other development platform there are many ways to achieve the desired result. To build the best WPF applications there are some recommended best practices foraccessibility,globalization and localization andperformance. The best practices can help developers building scalable and highly maintainable applications.

An option worth exploring

WPF is a powerful presentation technology built on the .NET Framework that enables the developers to create rich applications on a device-independent way. WPF is continuously evolving with each .NET Framework version. In .NET 4.5 there are some new features like a Ribbon control, improved performance when displaying large sets of data, synchronous and asynchronous validation of data, markup extensions for events anda lot more. With these new features WPF is a mature technology that is definitely worth a look.

Are your meetings worth attending?

$
0
0

"Remember, kids, your projects are due a week from Monday, so you'd better get started if you haven't already."

This imminently relatable phrase, or one like it, is probably the first exposure to nagging that most of us had outside of the home. Oh sure, Mom and Dad had nagged us for years to clean our rooms, say please and thank you, and wear jackets. But our teachers introduced us to business nagging. I'm using the term "business nagging" to characterize the general practice of nudging people to do things for common professional effort.

If you fast forward to your adult life, business nagging morphs into things like, "don't forget to sign off on your hours in payroll," and, "everyone must update their email signatures to use the company's official font by next week." The subject matter becomes more adult in nature, but the tone and implications do not. When you hear these phrases, you're transported back in time to junior high, when you needed to rely on a teacher to help prevent your general incompetence at life from creating unfavorable situations for yourself.

There's a subtle problem with business nagging growing up alongside of us. As children, we actually are pretty incompetent at looking out for own interests. Left to our own devices, we'll procrastinate on the school project and then pull an all-nighter ahead of turning in something that earns us a C minus. But as we grow to adulthood, we learn these lessons firsthand and wind up being generally decent at looking out for ourselves. We tend not to need nagging nearly as often to do things that will benefit us, so being nagged to do things that will benefit us winds up becoming largely superfluous.

And that leaves the most common form of business nagging: being nagged to do things that offer no obvious benefit to the recipient of the nagging. Signing off on your hours in payroll doesn't benefit you directly (except, perhaps, by removing the artificial threat not to compensate you for the work you've done). Changing your email signature doesn't benefit you directly. According to someone with some degree of power somewhere in the organization, you doing these things will benefit the company. Presumably, if the company benefits, so do you, somehow. But there is as much vagueness in that equation as there are "somes" in the previous sentence. From where you're sitting, it's just bureaucratic procedure having only one tangible benefit—getting the administrator of the business nagging to go away and leave you alone.

Perhaps the most endlessly renewable source of business nagging is the recurring meeting. It lurks in your Outlook calendar like the outrageous cable bill that you've been meaning to do something about. You should probably object or at least question its necessity, but every time it comes, you reason that it's easier to pay the piper than to expend the effort to put things right in the world. You go to the meeting. Or maybe you don't go, and you incur some business nagging: "guys, half the chairs in the department touch-point meeting were empty last week, so people really need to make sure they're going and getting there on time." Why should you go? Who knows. Because chairs were empty or something.

But a curious thing starts to happen if you're at a company for a while. You get assimilated to the culture and you stop asking "why" as much about things that had previously struck you as process for the sake of process. You gain authority and influence via seniority and you resolve cognitive dissonance by reasoning that all of the bureaucracy must have some purpose or else you wouldn't have gone along with it over the years. You inhabit a position to speak about what is in the best interests of the company, and you use that position to make policies, call meetings, and nag people for not showing up.

The creatures outside looked from pig to man, and from man to pig, and from pig to man again: but already it was impossible to say which was which.

-- George Orwell, Animal Farm.

If you're a software developer that's been at a company for a while, you probably have a love-hate relationship of sorts with meetings. It's in our very blood to hate meetings and prefer instead to be coding in a state of "flow." And yet newbies don't get invited to meetings. It's a status symbol of sorts that you're including in the weekly call with management and asked to sit in on all code reviews. And it's an entirely different thing when you call meetings because you're a programmer yourself and the meetings you call are meant to go over important things like build health, coding standards, architectural vision and the like. And since your meetings are important, who do the newbies and grunts think they are to skip them?! You're not calling them for your health—it's not as if you like them!

Should you find yourself in this situation, thinking these things, pause for a moment, and consider the nature of adult business nagging. Consider that people not showing up to the meetings you call is a sign that they don't perceive any benefit to doing so; they don't think you're going to provide anything that will help them do their jobs. Software developers are intelligent people who will optimize to get their work done as efficiently as possible, and they don't think your meeting is helping them toward that end. That's important feedback.

So before you fire up outlook to send out a sternly worded piece of business nagging, it's probably worth asking yourself why they don't see value in attending. And once you've worked out why they don't see value in it, it's probably worth addressing that deficiency. Not only will the group be better for it, but you'll learn things that will improve your chops as a technically focused leader.

This is a guest blog post by Erik Dietrich. Erik is the founder of DaedTech LLC, also an experienced programmer, software architect, team leader, coach, and technologist that enjoys working with a wide variety of programming languages, frameworks and tools. The majority of his recent experience has focused on the .NET framework, though over the years he has worked with C++, Java, and a number of other languages. Projects range from low-level driver and kernel module programming all the way up to user interface design, and the types of applications run the gamut from home automation to rigorous code analysis to line of business applications.

Overview of JavaScript Frameworks in 2015

$
0
0

We are well into 2015 and as a developer it is important to know what kind of technology or framework will be leading the way in the coming months. Every year the number of applications being created and used grows. Important is the fact that applications are becoming more and more complex, especially on the front end. Sending data from the client to the server, updating data stores or re-rendering parts of a page. These are things a developer needs to take care and this is where a JavaScript framework comes in.

In this post we will look at some of the frameworks you need to know about in 2015.

AngularJS

AngularJS is a JavaScript framework that is an open source platform which is maintained by Google. It is based on the MVC (Model-View-Controller) architecture and it primarily aims at making both development as well as testing efficient and easy. AngularJS extends traditional HTML code such that dynamic content can be easily served with the help of two way binding. 

AngularJS is an independent framework which means that it does not depend on any other JavaScript library, not even jQuery. When including jQuery in a project before referencing AngularJS it will use jQuery for DOM manipulation but this is not strictly needed - it will work without the jQuery reference. AngularJS is very popular and becoming more widely used in big companies. If there is one framework every developer needs to learn in 2015 it is AngularJS.

React

React is a JavaScript framework for building rich user interfaces and is a framework build by the developers of Facebook. It has a virtual DOM so it performs very fast and can be easily plugged into existing projects, as it does not care about the underlying technology. React Components provide a render method, which returns a virtual DOM structure which is, upon state changes, reconciled against the real DOM — and only the minimal set of DOM manipulations will occur in order to update your changes.

Popular websites like Facebook, Instagram, Khan Academy, New York Times and many more are using React in 2015. Given its benefits and burgeoning popularity, React looks likely to be one of the more popular web technologies in coming months.

Meteor

Meteor is an open source platform that recently secured $11.2 million in funding for creating real time JavaScript’s apps. With meteor you build templates and the pages update when the data in the database changes. Meteor can be used to create real time database applications.

With Meteor it is easy to build a modern user interface with a minimum of code thanks to its reactive programming model that extends all the way from the database to the screen. By using Isomorphic API's, the same code written in the same language can run on both client and server. Meteor is a flexible framework and can be customized by using AngularJS or any preferred component.

KnockoutJS

KnockoutJS is a framework that uses the MVVM pattern to produce UI manipulations. KnockoutJS uses declarative bindings to associate DOM elements with model data. This is done in a readable language (using the data-* attribute on the DOM elements). When the models data changes, the UI get refreshed instantly. KnockoutJS has dependency tracking to create chains of relationships between model data to transform and combine it and can use templates for complex UI's.

KnockoutJS is a free and open source framework that works with any other web framework. Since it has no dependencies it is easy to implement for small parts of a page. Learning the basics of KnockoutJS is easy and can be done in just a few hours so it’s not a big investment.

Dart & AngularDart

Dart is an open source project by Google that has the aim of simplifying web development. Dart code can run on the web and server and has recently been ported to AngularJS. Dart was founded in 2011 and its goal was to replace JavaScript as the most important language of web development on the open web platform. By porting it to Angular it meets many more of the current needs of web development. Together with Angular Dart, it can be used to build rich interfaces with data binding like KnockoutJS. AngularDart uses the MVC pattern and it therefore takes only a few hours to learn the basics for most professionals.

An ever shifting framework

When carrying out a web search on JavaScript frameworks there are a lot of results. It is hard to pick the best framework and it is even harder to pick the right framework for the task you need to complete. The frameworks mentioned in this post are only a few of them but they are frameworks that seem to be getting increasingly adopted (or have already been so) by a big group of developers. It’s also worth taking a look at Famo.us, EmberJS or BackBoneJS if you haven't already done too. The trends in development languages for 2015 are looking more diverse than ever!


Building enterprise apps with Indigo Studio

$
0
0

As anyone who works in app development will tell you, it’s an exciting time to be in the industry. With thousands of devices to develop for, exponential growth and amazing new releases coming out all the time, every day brings something new. For those who are ready and willing to constantly learn and push themselves, there are few industries as diverse, challenging and stimulating.

Whether it’s for the consumer, public sector or enterprise market, there are immeasurable opportunities to build apps and tools which can be accessed from different devices and which serve almost any purpose. However, given the variety of work out there, it can sometimes be complicated to align development with stakeholder goals and end-user needs, and this is especially the case in enterprise app development. The people who commission apps are often very different from end-users and have quite different aims and understandings to colleagues “on the shop floor”. We’ve all heard of cases where senior managers think junior colleagues need one thing - yet junior colleagues tell developers they need an app which does something rather different.

Of course, negotiating these differences, and finding a solution everyone is happy with is part of the appeal of working in this industry. Technological advances mean we no longer need to follow the waterfall project management model for large builds, and development is now much more collaborative and human-centred. Modern developers aren’t hidden away in back rooms building IT systems but have the opportunity to work alongside different colleagues across organisations.

Unachieved potential

For all the fantastic enterprise apps which exist, there are many more examples of failed and disappointing designs. Unfortunately, tools sometimes do fail to stand up to expectations and massive investments of time, energy and resources go to waste. Whether due to poor communication between stakeholders and developers, a gap of understanding about the purposes of the app or simply a build which doesn’t correspond with actual business practices, there are many reasons why and enterprise app can go wrong.

At Infragistics we understand the importance of collaboration when developing apps. Indigo Studio, our state of the art UX prototyping platform provides developers with the finest tools for collaborative development. Among its powerful features, it particularly specializes in letting developers demonstrate exactly how their builds will look and work without writing a single line of code. It’s this easy collaboration for development that we’ll be exploring below.

Wireframes: essential practice

Gathering feedback throughout the development of any design and development project is crucial. If simply left to chance - or the developer’s initial interpretation - the final product is very likely to be wildly different to stakeholder expectations. Wireframes are therefore a staple of enterprise app development - companies often invest considerable sums into enterprise apps and therefore being able to track app development is very important. Wireframes allow developers to present simple mock-ups to stakeholders and illustrate how they plan to take the development forward. From here they can negotiate what changes need to be made and what will or won’t be possible.

Indigo Studios includes a number of functions which take wireframing to the next level and really let stakeholders visualize how the app would work in their enterprise.

Functional, animated UI prototypes

With Indigo Studio, developers can build functioning prototypes that are dynamic and give a real impression of the user experience. Typical wireframe features such as content fields, images and column design come as standard yet the prototypes offer so much more. Indigo lets users build animated pages which rescale automatically for different sized screens and demonstrate the kinds of interactions end-users will have with the different parts of the app.

When stakeholders and end-users test the app, these prototypes make it far easier for them to picture what the final development will look like and make suggested changes.

Design realistic storyboards

Helping stakeholders picture how the app you’re designing would actually work in their business gives them the confidence it is going in the right direction. Indigo Studio does just this, by providing a large number of realistic storyboards which let you set the scene and tell stories around your app. They show the kinds of scenarios the app would be used in and how colleagues would interact with and use it at work. The storyboards actually allow you to snap screenshots of your prototype into the devices in the storyboards too, making them even more realistic. Again, this is all about inspiring confidence and letting stakeholders really picture how the end product will function in “real life”.

Enterprises want security

When developing apps for enterprise it is crucial to understand that businesses want to ensure that their investment is worthwhile and going to plan. The stakeholders who have commissioned an app are also very aware that if the app fails, they’ll have to answer to senior colleagues, so it’s understandable that they’re keen to get it right first time! Indigo Studio provides a powerful set of tools that allow developers to demonstrate what their app will look like and give stakeholders the security they’re need. In the end, it’s all about making the development process more collaborative, human focussed and effective.

What can we expect from SharePoint 2016?

$
0
0

It has been 3 years since the last release of the On-Premises version of SharePoint; Microsoft released SharePoint 2013 in February of that year. Since then a lot of things have changed, especially around Office 365. Microsoft hinted a couple of times, especially via their conferences, that the next version might be the last version released On-Premises. Microsoft has recently been putting the focus on their cloud product Office 365, and this message has caused a lot of confusion and rumours. People are worried that Microsoft has forgotten about large enterprises that cannot migrate entirely to the cloud just yet. So, apart from some hints regarding the next version, which was expected to be called SharePoint 2016, no official information was released by Microsoft until February 2015.

Julia White, general manager for the Office Product Management team, published a blog post about the future of SharePoint. She also officially announced the next version of the platform: SharePoint 2016. The message is that Microsoft is focusing on the cloud, but has not forgotten about their enterprise customers who still require On-Premises software. The keyword here is hybrid.

The best of two worlds: Hybrid

Julia White’s official blog post is somewhat quiet about the new features in SharePoint 2016. It does not become clear whether features available in Office 365 like Delve  and Power BI, will become available On-Premises too. However, she does focus on the new hybrid features; it will allow the best of both SharePoint On-Premises features as well as Office 365 in the Cloud.

“With SharePoint Server 2016, in addition to delivering rich On-Premises capabilities, we’re focused on robust hybrid enablement in order to bring more of the Office 365 experiences to our On-Premises customers.” - Julia White

New features are added in Office 365 all the time, while only some of the features become available in SharePoint On-Premises. For example, the Yammer integration introduced in Office 365 in 2013 was implemented about six months later in SharePoint On-Prem.

A hybrid solution will solve this issue. By using Office 365 for functionality only available in the Cloud, it will combine with SharePoint On-Premises for features that cannot be implemented in Office 365. Offering the very best of two worlds. By providing a seamless integration, the end user should not feel the difference between On-Premises and Office 365.

What’s new in SharePoint 2016?

Besides new features to create a hybrid solution, not much news has been released about the actual features in SharePoint 2016. Even when the hybrid features allow for a seamless integration, not everybody is interested in using Office 365 next to their SharePoint On-Premises installation. So, what new features will be added to SharePoint 2016?

The only new feature that is almost certain to be in SharePoint 2016 is the new Hybrid Search. This will be discussed further at Microsoft’s upcoming Ignite conference in May, so make sure you watch this session. Besides that, there is no official “What’s new in SharePoint 2016”, but we can make some guesses. Looking at the implementation of Windows 10, Microsoft has shown that it’s listening very carefully to their customers. If we then have a look at the most requested features of SharePoint 2016 at User Voice, we have extracted a new features top 5 (in random order):

  • Responsive Design: SharePoint has never performed really well when it comes to mobile views. Things have improved in SharePoint 2013, but it still lacks a responsive design out-of-the-box.
  • Deny permissions: The permission system in SharePoint is very powerful, but lacks one big feature: Deny permissions. For example, if you want to allow “All authenticated users” except a certain Active Directory group or user, you’ll have to add everyone separately. It’s not possible to deny permissions to a group or user.
  • Replacement for InfoPath: Microsoft announced a while ago that it is about to deprecate InfoPath. InfoPath offers a powerful solution to create custom forms, so what’s next after InfoPath?
  • Cross site collection navigation: Most SharePoint portal has multiple site collections, for sizing or authorization reasons (for example). However, the top and left navigation between site collections is cumbersome. SharePoint 2013 introduced managed navigation, but still didn’t solve all the issues.
  • Improved Yammer Integration: Integration with Yammer in SharePoint 2013 is working, but lacks some important features. Sharing of tags or users between SharePoint 2016 and Yammer would be very useful.

Microsoft is showcasing an early version of SharePoint 2016 at the Ignite conference. Bill Baer, Senior Product Manager for SharePoint, has published the top three sessions to learn more about SharePoint 2016. Every session discusses these new hybrid features, the last one focusing particularly on Hybrid Search.

We are so excited!

After a time of speculation and rumours, we are happy that we now officially know that SharePoint 2016 is coming later this year. It’s only 40 days until Ignite, where we will finally be able to see the new version. Here at Infragistics we are very interested in the new hybrid features, since the Cloud seems to be where SharePoint is heading. A hybrid SharePoint solution with all the new features in the Cloud, combined with a solid On-Premises solution, gives us the best of both worlds.

SharePlus - Your Mobile SharePoint Solution

Infragistics WPF SR Notes – April 2015: 15.1, 14.2, 14.1

$
0
0

Release notes reflect the state of resolved bugs and new additions from the previous release. You will find these notes useful to help determine the resolution of existing issues from a past release and as a means of determining where to test your applications when upgrading from one version to the next.

Release notes are available in both PDF and Excel formats. The PDF summarizes the changes to this release along with a listing of each item. The Excel sheet includes each change item and makes it easy for you to sort, filter and otherwise manipulate the data to your liking.

In order to download release notes, use the following links:

WPF 2015 Volume 1 Service Release (Build 15.1.20151.2008)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

WPF 2014 Volume 2 Service Release (Build 14.2.20142.2178)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

WPF 2014 Volume 1 Service Release (Build 14.1.20141.2283)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Infragistics Silverlight SR Notes – April 2015: 15.1, 14.2, 14.1

$
0
0

Release notes reflect the state of resolved bugs and new additions from the previous release. You will find these notes useful to help determine the resolution of existing issues from a past release and as a means of determining where to test your applications when upgrading from one version to the next.

Release notes are available in both PDF and Excel formats. The PDF summarizes the changes to this release along with a listing of each item. The Excel sheet includes each change item and makes it easy for you to sort, filter and otherwise manipulate the data to your liking.

In order to download release notes, use the following links:

Silverlight 2015 Volume 1 Service Release (Build 15.1.20151.2005)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Silverlight 2014 Volume 2 Service Release (Build 14.2.20142.2127)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Silverlight 2014 Volume 1 Service Release (Build 14.1.20141.2234)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Infragistics Windows Phone SR Notes – April 2015: 14.2, 14.1

$
0
0

Release notes reflect the state of resolved bugs and new additions from the previous release. You will find these notes useful to help determine the resolution of existing issues from a past release and as a means of determining where to test your applications when upgrading from one version to the next.

Release notes are available in both PDF and Excel formats. The PDF summarizes the changes to this release along with a listing of each item. The Excel sheet includes each change item and makes it easy for you to sort, filter and otherwise manipulate the data to your liking.

In order to download release notes, use the following links:

Windows Phone 2014 Volume 2 Service Release (Build 14.2.20142.2116)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Windows Phone 2014 Volume 1 Service Release (Build 14.1.20141.2215)

Notes in PDF Format
Notes in Excel Format
Notes in Word Format

Viewing all 2223 articles
Browse latest View live