Is Software Piracy Stealing?

This post is obviously not about WPF. I just read discussion on StackOverflow question: I’ve found my software as cracked download on The Internet, what to do?. Some of the answers and comments infuriated me so much I had to vent somewhere. Hence this post. Just to keep the tone of this blog, it will be in a form of tutorial – software piracy for dummies.

The question was posted by a software developer who found cracked version of his product. He asked what he could do to protect his product in which he invested six months of hard work.

I was surprised by the number of answers and comments that try to justify or minor software piracy in different ways. Even worse, StackOverflow is a place where almost all visitors are software professionals, the high number of them work that job for the money, and I didn’t expect there will be so much effort in explaining why software piracy is not so bad.

Just to be sure, I collected links that describe what is considered software piracy.

What is software piracy?

Numerous articles describe what software piracy is. Here are some top links from Google:

Read it, get your conclusion. As I read it, short interpretation is:

  • Vendors do not sell software like potatoes or cars, you do not buy the product, you buy the license to use the product.
    • Unless you are buying whole product, source code, and rights to do with it whatever you want. This kind of transactions are rare and are not subject of this post.
    • You can use software only under conditions product license allows
  • Copyright laws protect tThe software in the probably whole world. It is protected from unauthorized use and copying same as books and music.
  • Unauthorized use of software or use prohibited by the license is called copyright infringement of software. This phrase is how lawyers call it, for the rest of us it is software piracy
  • So, if you get and use software, but don’t have valid license, you are pirating software

How can software be pirated?

Here are some common ways of software pirating:

  • Copying software – most common. It’s making more installations than the license allows, usually one copy is bought and then it is given to family, friends or coworkers.
  • Downloading from internet P2P networks or file sharing sites (also very popular).
  • Buying counterfeit copies (look for internet ads that offer “huge discounts” and “OEM versions”). Call local wise guys, since it is usually big operation that involves production and distribution, so it needs an organization to run it.
  • Hard disk loading at computer shops

Ok, now that I’ve covered what software piracy is and how it is done, rant can begin.

About “Piracy is not stealing” idiocy

Let’s concentrate on software that has the price. You can argue it is not stealing, but pirating works something like this:

  • there is a commercial product that legally can be obtained only in exchange for money
  • pirate obtains said product without giving money in exchange for product

As we established before, this is called copyright infringement of software. Technically, it is theft, but it is illegal.

On the other hand, if you enter a shop and take some product without leaving money for it, it is called stealing.
If you take a cab ride and run without paying, it is called stealing.
If you stay in a hotel for a month and run without paying, it is called stealing.

So, if you get/take/obtain something that you should pay for, but without paying, it is stealing.

So, why we can’t call software piracy stealing? Pirates were expected to give money in exchange for the software license, but they didn’t. They got the product, but they didn’t pay for it. Ergo, stealing.

About “You should be happy somebody is pirating your software.”

That is one amusing sentence. The reasoning behind it is: “If there is no crack, your software is crap that nobody needs”. Maybe.
On the other hand, I don’t know how can anybody be happy when people steal from them. What kind of moron must I be to be happy in that situation?

Like I should put the following text on my web: “Hello world, I worked my ass of for last x months to make this software, that will make your life a little bit better, that will ease your job, that will make you some money, now come on and rip me off, make me and my family starve to death, so I know my software is worth something, and now I can die happy (and hungry)”.

A load of crap.
It is like this: “Hello world, I worked my ass off for last x months to make this software. Maybe it could make your life better, maybe it could ease your job, maybe it could make you some money. If you want to use it, I expect you to pay me. If you don’t have money, if you think it is not worth as much as I ask, or if you don’t want to pay me for any other reason, then you are free to continue your life and work the same way you did before, without my software. Thank you.”

I spent time creating software with the idea that it will be worth to people in one specific market. I don’t need pirates to justify my effort. Paying customers are more than enough justification. I would be very worried if there are no customers.

About “People who use pirated copies won’t buy anyway.”

This is the variation of the fallacy from the previous paragraph. The software is created with the idea of helping people do their job or have fun or whatever. Essence is making life better. Not all software achieves this, but that is another story.

My software (I hope) helps people do their job better, faster and easier. It makes them cash by helping them do more at the same time. I want some of that cash, and it is the amount they can save/earn in a couple of hours using my software. If they don’t pay me, I don’t want them to use it. Simple. My software, my rules and copyright law.

Somebody pulled Microsoft as an example. Allegedly, Microsoft was not very eager in fighting piracy in the developing countries as a method of penetrating the market. Moto was “they won’t buy anyway, so it’s better to let them use pirated windows than some other OS”. But there are very few companies that can do this. Small companies can’t wait 5-10 years like Microsoft can.

About “Price is too high, people cannot afford it.”

I found one very funny example in comments. It is about Adobe Photoshop pirating. The poster suggested that Photoshop piracy rate is very high because it is expensive. Well, it is quite pricey. And it should be. It is probably the best tool on the market (I don’t know for sure, not my area, please correct me if I’m wrong). Adobe has a large team working on a product. Those people earn their paychecks every month. Adobe must charge a premium if we want to have better versions of Photoshop.

Those who cannot pay are free to use any other tools they can afford. Photoshop is not the only tool in the world. There are other tools. Maybe not that capable, maybe they will take more time than Photoshop for the same tasks. Use what you can afford, and then save money and buy Photoshop if you need it.

You cannot buy big Mercedes for the price of small Chevrolet. Why is then considered normal to steal Photoshop if you cannot afford it?

About “You created software, it does not cost you anything to make copies.”

This is one where my head wants to explode. Even more so when I hear it from software developers who expects to get a regular paycheck. Basic naïve simplified software development economics:

  • n people created software for m months
  • for this m months, people working on software had to eat something, so they got some salary s
  • the total cost of development is about n * m * s plus some other expenses which in the end gives an awful lot of money (this is economics term)
  • now somebody estimates that we can sell a boat load of copies, and then it divides total development cost with a boat load, adds some margin and determines the unit price
  • now we wait to sell a boat load of copies just to break even
  • after we sell a boat load of copies, we start to earn and get filthy rich

So, yes, the act of copying software over internet costs almost nothing. The problem is that small software companies invest in development counting on future income. If pirates eat that income, it’s usually the end of company and product.

So, if you like some piece of software, buying it will help the company survive and upgrade product. Making free copies and pirating will likely kill it.

Software piracy is stealing

Third time’s the charm. This is the third title that says software piracy is stealing. This is for Google and other search engines. I want them to know what I think. I hope it’s clear.

What struck me on the StackOverflow site was that lots of the software developers condone piracy. There are some excuses used to justify pirating. The only conclusion is that developers are heavily pirating software.


  • I am not a lawyer. I don’t want to argue about copyright law interpretation. I wrote mine; you are free to do so in comments.

How to Bind to ListBox.ItemsSource inside UserControl


The post describes two ways of WPF data binding to elements inside WPF user control. Example shows how to establish WPF user control data binding by:

Complete source code is available for download here.


While working on my project, I needed identical controls and functionality on several windows. The solution was to create WPF user control and use it in all windows.

Control I created contains ListBox , button, textbox and few other controls (panel, border). Creating this user control was easy – define the layout and add standard WPF controls. Step two is using this custom control in windows and other user controls.

Adding user control to other window or user controls is simple:

  • add a reference to a namespace (and assembly if the user control is not in the same assembly as Window where it will be used)
  • add a control to XAML

So, I added my new user control to the window, and next step is to define binding. Type ItemsSource=”{Binding myList}” and the red squiggly line immediately appeared, notifying me that there is no  ItemsSource in my user control.

Binding to Dependency Property in User Control

My user control is derived from UserControl , which does not have ItemsSource property. The first idea is to create a property on user control that exposes ItemsSource property.  The user control will have dependency property of type IEnumerable for ItemsSource, and listbox will have data binding that binds to this property. Consumers of this user control will then be able to bind to this property in XAML, just like standard listbox.

Binding to DataContext of User Control

While reading through UserControl properties, I noticed that I forgot about DataContext property. Second way can be to assign DataContext to my control and then bind ListBox inside my user control. Consumer will bind list to user control DataContext and inside user control, listbox will bind to that DataContext

User Control Example

I decided to test both of solutions to see which one feels better. For test, I created simple user control that contains two listboxes, one will be bound to DataContext, other to dependency property. Here is the code:

<UserControl x:Class="ListboxInUserControlDemo.ListboxInUserControl"
Height="300" Width="500">
<ColumnDefinition />
<ColumnDefinition Width="10"/>
<ColumnDefinition />
<ListBox ItemsSource="{Binding Path=.}" Grid.Column="0"/>
<ListBox x:Name="listBox2"
ItemsSource="{Binding ElementName=myUserControl, Path=MyItemsSource}"

In above code, first listbox have ItemsSource bound to current DataContext. Specification Path=. is used to bind to current source (see Binding.Path Property for details). Specifying Path=. is not mandatory, it could be written like this: ItemsSource="{Binding}". I put it here just to remind myself what Path=. actually means.
The second listbox gets ItemsSource from dependency property MyItemsSource. Since ItemsSource is bound to property of this user control, there must be specified element whose property is bound to listbox, so there is: ElementName=myUserControl.

Most of the code behind is code needed to define dependency property:

using System.Collections;
using System.Windows;
using System.Windows.Controls;

namespace ListboxInUserControlDemo
/// <summary>
/// Interaction logic for ListboxInUserControl.xaml
/// </summary>
public partial class ListboxInUserControl : UserControl
public static readonly DependencyProperty MyItemsSourceProperty;

static ListboxInUserControl()
ListboxInUserControl.MyItemsSourceProperty =
typeof(IEnumerable), typeof(ListboxInUserControl));

public IEnumerable MyItemsSource
return (IEnumerable)GetValue(ListboxInUserControl.MyItemsSourceProperty);
SetValue(ListboxInUserControl.MyItemsSourceProperty, value);

public ListboxInUserControl()

Consuming User Control in Window

Now we have user control defined. Next step is to put it into window and test behavior. To see difference between binding methods, example will contain two copies of the user control. One will bind to DataContext, while second will bind to dependency property. On each copy of user control, one listbox will show data, while other will be empty.

<Window x:Class="ListboxInUserControlDemo.Window1"
Title="Window1" Height="400" Width="550"
DataContext="{Binding RelativeSource={RelativeSource Self}}">
<TabItem Header="DataContext binding" >
<lbUserControl:ListboxInUserControl DataContext="{Binding TestList}"/>
<TabItem Header="Dependency Property Binding">
<lbUserControl:ListboxInUserControl MyItemsSource="{Binding TestList}"/>

Window contains TabControl with two TabItems. Each TabItem have one ListboxInUserControl.

There is nothing special in code behind of this window, standard constructor and initialization for TestList property:

using System.Collections.Generic;
using System.Windows;

namespace ListboxInUserControlDemo
public partial class Window1 : Window
public Window1()

List<string> _testList;
public List<string> TestList
if (_testList == null)
return _testList;

private void InitList()
_testList = new List<string>();
_testList.Add("Lorem ipsum dolor sit amet,");
_testList.Add("consectetur adipiscing elit. ");
_testList.Add("Duis mollis egestas ornare. ");
_testList.Add("Cras diam est, sollicitudin ");
_testList.Add("quis vulputate sed, lacinia.");
_testList.Add("Phasellus lorem nunc, fringilla eget posuere");
_testList.Add("sed, tincidunt nec felis. Ut non dui ut");
_testList.Add("metus auctor scelerisque quis ornare leo.");
_testList.Add("Integer eget purus tellus. Nullam ut urna dui.");
_testList.Add("Quisque sed enim magna, sed.");

So, let’s see what happens when I run this code.
The first user control on first TabItem binds to DataContext to TestList the property of a window. Left listbox in user control binds to that DataContext and it will show contents of TestList. Right listbox will be empty since there is no binding to the dependency property MyItemsSource.
Second user control binds dependency property MyItemsSource to TestList property of the window but does not bind DataContext. On this tab left listbox will be empty, and right listbox will show contents of TestList.

There it is. Two ways to databind to ListBox inside the user control. This, of course, works for all types of controls.
I prefer databinding with DataContext. Defining DependencyProperty adds lots of code in codebehind but does not save anything when you consume UserControl.

The complete code is available for download here.