If this is an operation on an `IList&lt;PointF&gt;`, then it should be an extension method on `IList&lt;PointF&gt;`. 

Generally, `Utils` and `Helper` type classes should be avoided. More often than not, you will find that what you may _think_ is a utility method, is actually a rather specific method that probably belongs in a class of its own (just like you say). However, there will be domain specific cases where `Util`-like classes (classes which group related useful methods) are valid entities. 

There is nothing wrong with &quot;global&quot; variables and methods. You use them all the time. The framework likes to call them &quot;static&quot; classes or &quot;static&quot; methods.

I rarely need to, but I usually add an internal static class Util in the namespace that the method/variable is needed for C# and a module for VB.NET.

Samples from .NET Framework

 - `System.Collections.Specialized.CollectionsUtil`
 - `System.Net.WebUtility`
 - Check Microsoft&#39;s source code for .NET Framework. You will find numerous internal utility classes.

You should put it into a &#39;ListUtilities&#39; or `PointListUtilities` class, of course.  Then you aren&#39;t breaking the single responsibility principle, which is the primary problem with a catch-all &#39;Utilities&#39; class.

Facebook graph API tells me I can get a profile picture of a user using

http://graph.facebook.com/517267866/picture?type=large

which works fine. However, when you type above URL into a browser, the actual address of the image is

http://profile.ak.fbcdn.net/profile-ak-snc1/v227/560/83/n517267866_1928.jpg

How can I get the second URL using the first one programmatically?

Getting the &quot;real&quot; Facebook profile picture URL from graph API

In my android app, I wanted to start an activity &#39;B&#39; from initial activity &#39;A&#39;. I have created classes for both of these. However when using following code to start B, I get a runtime error: `application has stopped unexpectedly, try again`. Here is my code:

    Intent myIntent = new Intent(this, AddNewActivity.class);
    startActivity(myIntent); 

When I added a new entry in `AndroidManifest.xml/manifest/application/activity/intent-filers` for activity B then the application worked.

I have two questions:

* When there are multiple activities entries in `AndroidManifest.xml`, how does android know which activity to start first?
* I could not understand intent-filters. Can anyone please explain.

Here is my partial `AndroidManifest.xml`

    &lt;application android:icon=&quot;@drawable/icon&quot; android:label=&quot;@string/app_name&quot;&gt;
        &lt;activity android:name=&quot;.ListAllActivity&quot;
                  android:label=&quot;@string/app_name&quot;&gt;
            &lt;intent-filter&gt;
                &lt;action android:name=&quot;android.intent.action.MAIN&quot; /&gt;
                &lt;category android:name=&quot;android.intent.category.LAUNCHER&quot; /&gt;
            &lt;/intent-filter&gt;
        &lt;/activity&gt;
        &lt;activity android:name=&quot;.AddNewActivity&quot; android:label=&quot;@string/app_name&quot;&gt;
            &lt;intent-filter&gt;
                &lt;action android:name=&quot;android.intent.action.MAIN&quot; /&gt;
                &lt;category android:name=&quot;android.intent.category.LAUNCHER&quot; /&gt;
            &lt;/intent-filter&gt;
        &lt;/activity&gt;
    &lt;/application&gt;




What are intent-filters in Android?

I generally live by the rule that Global variables / functions are evil and that every piece of code should live in the class to which it pertains.

This is a very easy rule to follow, and I believe that I haven&#39;t ever run into an issue with this rule until now.

Today, however, I need to add a function to my *assembly* rather than to a specific class.  That is, almost all of my classes *could* have a use for this particular function.

**Where should I put this function (+1 overload)?**

If I put it in a &quot;Utilities&quot; class, I feel dirty.  If I tack it on to a semi-related class, and let other classes call it directly, I feel worse.

This particular piece of code basically chops a `IList&lt;PointF&gt;` into a normalized list.  I feel right now that adding it as an extension method on `IList&lt;PointF&gt;` may be the best bet...

If a &quot;Utilities&quot; class is evil, where do I put my generic code?

I generally live by the rule that Global variables / functions are evil and that every piece of code should live in the class to which it pertains.
This is a very easy rule to follow, and I believe that I haven't ever run into an issue with this rule until now.
Today, however, I need to add a function to my assembly rather than to a specific class. That is, almost all of my classes could have a use for this particular function.
Where should I put this function (+1 overload)?
If I put it in a "Utilities" class, I feel dirty. If I tack it on to a semi-related class, and let other classes call it directly, I feel worse.
This particular piece of code basically chops a <code>IList&#x3C;PointF></code> into a normalized list. I feel right now that adding it as an extension method on <code>IList&#x3C;PointF></code> may be the best bet...

I&#39;m creating new processes using `System.Diagnostics.Process` class from my application.&lt;br&gt;&lt;br&gt; I want this processes to be killed when/if my application has crashed. But if I kill my application from Task Manager, child processes are not killed.&lt;br&gt;&lt;br&gt; Is there any way to make child processes dependent on parent process?

Kill child process when parent process is killed

I would like to specify that a decimal field for a price must be &gt;= 0 but I don&#39;t really want to impose a max value.

Here&#39;s what I have so far...I&#39;m not sure what the correct way to do this is.

    [Range(typeof(decimal), &quot;0&quot;, &quot;??&quot;] public decimal Price { get; set; }

How to specify a min but no max decimal using the range data annotation attribute?

How can I kill some active processes by searching for their .exe filenames in C# .NET or C++?

Kill some processes by .exe file name

In C#, what is the preferred way to add (deep) copy functionality to a class? Should one implement the copy constructor, or rather derive from `ICloneable` and implement the `Clone()` method?  

&lt;b&gt;Remark&lt;/b&gt;: I wrote &quot;deep&quot; within brackets because I thought it was irrelevant. Apparently others disagree, so I asked [whether a copy constructor/operator/function needs to make clear which copy variant it implements](https://stackoverflow.com/questions/3350725/does-a-copy-constructor-operator-function-need-to-make-clear-which-copy-variant-i).


Copy constructor versus Clone()

I need a way to take screenshots of my functional tests. Right now I&#39;m using Selenium 2 with C# bindings. I pretty much want to take a screenshot at the end of the test to make sure the desired page is displayed. Are there any particular tools you guys know of that I can incorporate into my C# code that will trigger a screenshot? I couldn&#39;t find a built-in Selenium 2 solution (without looking it over). 

Best way to take screenshots of tests in Selenium 2?

Say you&#39;re writing method `foo()` in class A.  foo doesn&#39;t ever access any of A&#39;s state.  You know nothing else about what foo does, or how it behaves.  It could do anything.

Should foo always be static, regardless of any other considerations?  Why not?

It seems my classes are always accumulating many private helper methods, as I break tasks down and apply the only-write-it-once principle.  Most of these don&#39;t rely on the object&#39;s state, but would never be useful outside of the class&#39;s own methods.  Should they be static by default?  Is it wrong to end up with a large number of internal static methods?

Should Java methods be static by default?

I know the question has been &lt;a href=&quot;https://stackoverflow.com/questions/49002/prefer-composition-over-inheritance&quot;&gt;discussed before&lt;/a&gt;, but it seems always under the assumption that inheritance is at least sometimes preferable to composition. I&#39;d like to challenge that assumption in hopes of gaining some understanding.

My question is this: &lt;em&gt;Since&lt;/em&gt; you can accomplish anything with object composition that you can with classical inheritance &lt;em&gt;and since&lt;/em&gt; classical inheritance is very often abused[1] &lt;em&gt;and since&lt;/em&gt; object composition gives you flexibility to change the delegate object runtime, &lt;strong&gt;why the would you &lt;em&gt;ever&lt;/em&gt; use classical inheritance?&lt;/strong&gt;

I can sort of understand why you would recommend inheritance in some languages like Java and C++ that do not offer convenient syntax for delegation. In these languages you can save a lot of typing by using inheritance whenever it is not clearly incorrect to do so. But other languages like Objective C and Ruby offer both classical inheritance &lt;em&gt;and&lt;/em&gt; very convienient syntax for delegation. The Go programming language is the only langage that to my knowledge has decided that classical inheritance is more trouble than it&#39;s worth and supports only delegation for code reuse. 

Another way to state my question is this: Even if you know that classical inheritance is not incorrect to implement a certain model, is that reason enough to use it instead of composition?

[1] Many people use classical inheritance to achieve polymorphism instead of letting their classes implement an interface. The purpose of inheritance is code reuse, not polymorphism. Furthermore, some people use inheritance to model their intuitive understanding of an &quot;is-a&quot; relationship &lt;a href=&quot;http://en.wikipedia.org/wiki/Circle-ellipse_problem&quot;&gt;which can often be problematic&lt;/a&gt;.

&lt;strong&gt;Update&lt;/strong&gt;

I just want to clarify what I mean exactly when I talk about inheritance:

I am talking about &lt;a href=&quot;http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)&quot;&gt;the kind of inheritance whereby a class inherits from a partially or fully implemented base class&lt;/a&gt;. I am &lt;em&gt;not&lt;/em&gt; talking about inheriting from a purely abstract base class which amounts to the same thing as implementing an interface, which I for the record am not arguing against.

&lt;strong&gt;Update 2&lt;/strong&gt;

I understand that inheritance is the only way to achieve polymorphism i C++. In that case it&#39;s obvious why you must use it. So my question is limited to languages such as Java or Ruby that offer distinct ways to achieve polymorphism (interfaces and duck typing, respectively).

Why use inheritance at all?

Could someone give me an example of Duck Typing inheritance in Javascript? I&#39;m exploring OO javascript and I&#39;ve heard about duck typing but can&#39;t see any examples of it being used in javascript.



Duck Typing in Javascript

I have a Wicket page class that sets the page title depending on the result of an abstract method.

    public abstract class BasicPage extends WebPage {

        public BasicPage() {
            add(new Label(&quot;title&quot;, getTitle()));
        }

        protected abstract String getTitle();

    }

NetBeans warns me with the message &quot;Overridable method call in constructor&quot;, but what should be wrong with it? The only alternative I can imagine is to pass the results of otherwise abstract methods to the super constructor in subclasses. But that could be hard to read with many parameters.

What&#39;s wrong with overridable method calls in constructors?

**First question**

Please, could you explain me how simpliest ACL could be implemented in MVC.

Here is the first approach of using Acl in Controller...

    &lt;?php
    class MyController extends Controller {
    
      public function myMethod() {        
        //It is just abstract code
        $acl = new Acl();
        $acl-&gt;setController(&#39;MyController&#39;);
        $acl-&gt;setMethod(&#39;myMethod&#39;);
        $acl-&gt;getRole();
        if (!$acl-&gt;allowed()) die(&quot;You&#39;re not allowed to do it!&quot;);
        ...    
      }
    
    }
    ?&gt;

It is very bad approach, and it&#39;s minus is that we have to add Acl piece of code into each controller&#39;s method, but we don&#39;t need any additional dependencies!

Next approach is to make all controller&#39;s methods `private` and add ACL code into controller&#39;s `__call` method.

    &lt;?php
    class MyController extends Controller {
    
      private function myMethod() {
        ...
      }
    
      public function __call($name, $params) {
        //It is just abstract code
        $acl = new Acl();
        $acl-&gt;setController(__CLASS__);
        $acl-&gt;setMethod($name);
        $acl-&gt;getRole();
        if (!$acl-&gt;allowed()) die(&quot;You&#39;re not allowed to do it!&quot;);
        ...   
      }
    
    }
    ?&gt;

It is better than previous code, but main minuses are...

 - All controller&#39;s methods should be private 
 - We have to add ACL code into each controller&#39;s __call method.

The next approach is to put Acl code into parent Controller, but we still need to keep all child controller&#39;s methods private.

What is the solution? And what is the best practice?
Where should I call Acl functions to decide allow or disallow method to be executed.

**Second question**

Second question is about getting role using Acl. Let&#39;s imagine that we have guests, users and user&#39;s friends. User have restricted access to viewing his profile that only friends can view it. All guests can&#39;t view this user&#39;s profile. So, here is the logic..

 - we have to ensure that method being called is profile
 - we have to detect owner of this profile
 - we have to detect is viewer is owner of this profile or no
 - we have to read restriction rules about this profile
 - we have to decide execute or not execute profile method

The main question is about detecting owner of profile. We can detect who is owner of profile only executing model&#39;s method $model-&gt;getOwner(), but Acl do not have access to model. How can we implement this?


How can I implement an Access Control List in my Web MVC application?

How can I declare a global variable in JavaScript?



How to declare a global variable in JavaScript

Working on an idea for a simple `HTMLElement` wrapper I stumbled upon the following for Internet&amp;nbsp;Explorer and [Chrome][1]:

For a given `HTMLElement` with an `id` in the DOM tree, it is possible to retrieve the `&lt;div&gt;` using its ID as a variable name or as a property of `window`. So for a `&lt;div&gt;` like

```html
&lt;div id=&quot;example&quot;&gt;some text&lt;/div&gt;
```

in [Internet&amp;nbsp;Explorer&amp;nbsp;8][2] and Chrome you can do:

```js
alert(example.innerHTML); // Alerts &quot;some text&quot;.
```

or

```js
alert(window[&quot;example&quot;].innerHTML); // Alerts &quot;some text&quot;.
```

So, does this mean *every element in the DOM tree* is converted to a property on the global object? And does it also mean one can use this as a replacement for the `getElementById` method in these browsers?


  [1]: http://en.wikipedia.org/wiki/Google_Chrome
  [2]: http://en.wikipedia.org/wiki/Internet_Explorer_8

Do DOM tree elements with IDs become global properties?

Here are 2 files:

    // main.js
    require(&#39;./modules&#39;);
    console.log(name); // prints &quot;foobar&quot;

    // module.js
    name = &quot;foobar&quot;;

When I don&#39;t have &quot;var&quot; it works. But when I have:


    // module.js
    var name = &quot;foobar&quot;;

name will be undefined in main.js.

I have heard that global variables are bad and you better use &quot;var&quot; before the references. But is this a case where global variables are good?

Share variables between files in Node.js?

I know that global variables are bad.

But if I am using node&#39;s module &quot;util&quot; in 40 files in my framework, isn&#39;t it better to just declare it as a global variable like:

    util = require(&#39;util&#39;);

in the index.js file instead of writing that line in 40 files?

Cause I often use the same 5-10 modules in each file, that would save a lot of time instead of copy paste all the time.

Isn&#39;t DRY good in this case?

Global variables for node.js standard modules?

If so, what is the syntax for such a declaration?

Can global constants be declared in JavaScript?

I want to create a class with utility methods, for example

    public class Util {
        
       public static void f (int i) {...}

       public static int g (int i, int j) {...}

    }

Which is the best method to create an utility class?

Should I use a private constructor?

Should I make the utility class for abstract class?

Should I do nothing?

Content Type	Original Author	Original Content on Stackoverflow
Question	John Gietzen	View Question on Stackoverflow
Solution 1 - C#	Håvard S	View Answer on Stackoverflow
Solution 2 - C#	AMissico	View Answer on Stackoverflow
Solution 3 - C#	Ben Voigt	View Answer on Stackoverflow

If a "Utilities" class is evil, where do I put my generic code?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

What are intent-filters in Android?

Getting the "real" Facebook profile picture URL from graph API

Attributions