sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: kubernetes
Issue: "don't require a load balancer between cluster and control plane and still be HA"
Labels: priority/backlog,sig/network,area/kubelet,area/kube-proxy,area/HA,sig/node,sig/api-machinery,kind/api-change,kind/feature,help wanted,lifecycle/frozen,triage/accepted

Can I connect kube-proxy to multiple api servers like:

`—master=http://master1:8080,http://master2:8080,http://master3:8080` ?
Repository: go
Issue: proposal: os/v2: Stdin, Stdout and Stderr should be interfaces
Labels: v2,Proposal

The three variables os.Stdin, os.Stdout, and os.Stderr are all *Files, for historical reasons (they predate the io.Writer interface definition).

They should be of type io.Reader and io.Writer, respectively. This would make it easier to do interesting things with special input or output processors. For instance, one could say

os.Stdout = bufio.NewWriter(os.Stdout)
os.Stderr = bufio.NewWriter(os.Stderr)

and all output, including from log.Printf and fmt.Printf, would be buffered. Much more imaginative things would also be possible.

Also, *File is the root of a large dependency tree that simple programs would be able to avoid.

Can't change it now, but we could in Go 2.
Repository: kubernetes
Issue: Needed: field-level extension mechanism
Labels: priority/backlog,area/api,area/apiserver,sig/api-machinery,kind/feature,lifecycle/frozen

We don't have a good mechanism for plugging extension fields into objects. That is, suppose we have an Autoscaler type, and we want user on FooCloud to be able to set some extra fields in Autoscaler.FooExtensions for the FooCloudProvider to make use of.

Currently, we do this by letting everyone add a *FooCloudOptions variable into the Autoscaler type. The downside of this is that people have to modify things in our code base, and that these options appear whether or not they actually exist on the cluster.

Another alternative is adding a `CloudProviderOptions RawExtension` (e.g., []byte) and letting people dump whatever options they want there. This has the downside that apiserver can't validate or document the contents of that field, nor can it convert it between versions, etc. Using an annotation is basically the same thing.

So my idea here is to leverage federated API servers. Basically, you'd make a new apiserver (which should be very easy in the future) and drop-in a Autoscaler type. This would be exactly the same as the main Autoscaler type, except for the addition of your custom fields. (We'd have to make some rules so this can work correctly.) Then we point /apis/scale/autoscalers at your apiserver instead of the main apiserver.

The downsides:
- depends on incomplete features.
- Only one such override per resource per cluster would be possible.
- Only possible for resources that don't have custom apiserver logic (which should be everything)

But the good part is that we'd be able to deliver the validation, documentation, conversion features users expect.
Repository: go
Issue: cmd/compile: Suggest typo fixes for resolution errors
Labels: NeedsInvestigation,compiler/runtime

In case of "cannot find package" or "undefined" errors, perhaps we should suggest typo fix solutions?

The basic idea is to look for all allowed names in that position with the minimum levenshtein distance (perhaps capping it at 3 or something), and suggest those.

[Rust does this](http://is.gd/BYma9H) and it's pretty useful.
Repository: rust
Issue: Add levenshtein distance based suggestions everywhere
Labels: C-enhancement,A-diagnostics,P-low,E-mentor,T-compiler

Currently, we suggest typo fixes in case of function calls, locals, and field accesses. So, both the marked lines below will suggest the correct fix:

``` rust
struct A {foo: u8}
fn main() {
    let x = A {foo: 1};
    x.fob; // here
    let aaaaaaa=1;
    let z = aaaaaab; // here
}
```

However, this is not the case for [imports](http://is.gd/LSn7rA), [crates](http://is.gd/p6YXoT), and [inline paths](http://is.gd/wGtIEU). We should fix this.

This is probably not an easy bug, but should be fun. Basically you need to look for the source of the "could not find X" error, and do something similar to https://github.com/rust-lang/rust/blob/99925fb562086ff789df95220104f9d8d5fc8b3c/src/librustc_resolve/lib.rs#L3625

@apasel422 @Wafflespeanut want to work on this?
Repository: TypeScript
Issue: [tsserver] documentation "about how to implement tsClient?"
Labels: Docs

I'm implementing tsClient inside Eclipse, but it's very hard for me, because there are no documentation about protocol. So I study implementation with sublime, vim and vscode, but it's not my language, so it's a little hard.

So, it should be very cool if you could provide a documentation to implement tsClient, I mean request/response protocol. 

We could take a simple sample: 
- open a document. 
- do a completion.
- change the editor content to show how to synchronize editor with tsserver. There are 2 means to do that:
  - use "change" (I must study why it doesn't work for me, but if I have a documentation, it will help me a lot).
  -  use "tmpfile"
- do a completion again with the editor which have changed.
- close the document.

To explain that, you could starts tsserver with Windows cmd, and shows request/response. So any user will able to play with your tsserver.

After that you could speak about advanced topic like validation with event.

Thanks for your help!
Repository: rust
Issue: UFCS can bypass trait stability
Labels: A-stability,T-compiler,C-bug,F-staged_api

Right now we have a trick in the standard library where sometimes a trait is unstable but the methods are stable. This is primarily used for `SliceConcatExt` to make `join` stable on slices but you can't import the trait or rely on the fact that it's defined through a trait.

There are a few ways to bypass this, however:

``` rust
// foo.rs
#![feature(staged_api)]                        
#![stable(feature = "foo", since = "1.2.0")]   

#[unstable(feature = "bar", issue = "0")]      
pub trait Foo {                                
    #[stable(feature = "foo", since = "1.2.0")]
    fn foo(&self) {}                           
}                                              

#[stable(feature = "foo", since = "1.2.0")]    
impl Foo for i32 {}                            
```

``` rust
// bar.rs
#![allow(warnings)]               

extern crate foo;                 

// this is expected to compile and work A-OK                                  
fn test1() {                      
    use foo::*;                   
    1i32.foo();
}                                 

// this is expected to fail to compile (e.g. needs the feature)
fn test2() {                      
    use foo::Foo; //~ ERROR
}                                 

// This should *also* fail to compile, but it does not
fn test3() {                      
    foo::Foo::foo(&1) // no error
}                                 

// Like above, this should also fail to compile, but it does not
fn test4() {                      
    <i32 as foo::Foo>::foo(&1) // no error
}                                 

fn main() {}                      
```

```
$ multirust run nightly rustc foo.rs --crate-type lib
$ multirust run nightly rustc bar.rs
bar.rs:11:9: 11:17 error: use of unstable library feature 'bar' (see issue #0)
bar.rs:11     use foo::Foo;
                  ^~~~~~~~
bar.rs:11:9: 11:17 help: add #![feature(bar)] to the crate attributes to enable
error: aborting due to previous error
```

I thought that we crawled paths pretty meticulously, but apparently not :(

cc @petrochenkov 
cc @rust-lang/libs
Repository: TypeScript
Issue: Cascading errors when incorrectly extending a generic type
Labels: Bug,Help Wanted

Only one error should be reported for `xyz`: "Generic type '{0}' requires {1} types argument(s).". Subsequent uses of `xyz` should not report errors. In the example below, calling `new` does, and previously referring to properties on an instance of `xyz` did too.

Note that this cleanup should not break the language services' ability to tell the user that `xyz` extends `abc` and that it will inherit members from it once a type argument is provided. (We may have to add tests to cover this case.)

From tests/cases/compiler/recursiveBaseConstructorCreation3.ts:

``` ts
    declare class base<T> {
    }
    declare class abc<T> extends base<T> {
        foo: xyz;
    }
    declare class xyz extends abc {
                              ~~~
!!! error TS2314: Generic type 'abc<T>' requires 1 type argument(s).
    }

    var bar = new xyz(); // Error: Invalid 'new' expression.
              ~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
    var r: xyz = bar.foo;
```
Repository: go
Issue: runtime: c-shared builds fail with musllibc
Labels: compiler/runtime

Currently, some of the init_array functions provided by a c-shared build expect to be called with (argc, argv, envp) arguments as is done by glibc, but this isn't specified by the ELF gABI for DT_INIT_ARRAY (http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#init_fini), and isn't done with other libc implementations like musllibc.

CC @ianlancetaylor @mwhudson
Repository: go
Issue: cmd/compile: storing pointer of a local value escapes
Labels: Performance,compiler/runtime

Using `go.1.5.1`

Consider the following program:

``` go
package main

func foo() {
    type node struct{ n0, n1 *node }
    var nodeCache [1024]node
    var nodePtrs [1024]*node
    nodes := nodePtrs[:0]

    n := &nodeCache[0]
    n.n0 = &nodeCache[1]
    n.n1 = &nodeCache[2]

    nodes = append(nodes, n)
}

func main() {
}
```

Currently, the compiler thinks that nodeCache escapes:

```
joetsai@zynx: ~ $ go build -gcflags=-m main11.go 
# command-line-arguments
./main11.go:16: can inline main
./main11.go:5: moved to heap: nodeCache
./main11.go:10: &nodeCache[1] escapes to heap
./main11.go:11: &nodeCache[2] escapes to heap
./main11.go:9: &nodeCache[0] escapes to heap
./main11.go:7: foo nodePtrs does not escape
```

The compiler should be able to track that pointers to nodeCache leak to nodePtrs and since nodePtrs never escapes, nodeCache never escapes as well.

This would be really useful for operating on trees and graphs (that are bounded in size) without any heap allocations.
Repository: go
Issue: encoding/xml: add generic representation of XML data
Labels: Proposal,Proposal-Accepted

It would be helpful to have a more 'natural' data-object for XML data, so that all the information is preserved. Something like the DOM nodes in javascript.

Here is an implementation of what I would expect an XML parser to return:
https://github.com/fluhus/gostuff/tree/master/xmlnode

What do you think? Can we add such a feature to the standard XML parser?
Repository: TypeScript
Issue: Class View in Visual Studio?
Labels: Suggestion,Visual Studio

TypeScript has some integration with VS, but the it doesn't seem to populate the class view window. Are there plans to implement this?
Repository: go
Issue: x/mobile/example: paint event sending is too much on iOS
Labels: mobile

- Go 1.5.2(OS-X 10.10)
- target device: iPhone5s iOS 9.1
- expected behavior: Just a good paint frequency.
- instead behavior: high CPU load and Irregular paint timing. 

iOS device requires following patch

```
diff --git a/example/basic/main.go b/example/basic/main.go
index 2b2e0c9..f826c45 100644
--- a/example/basic/main.go
+++ b/example/basic/main.go
@@ -89,7 +89,7 @@ func main() {
                                a.Publish()
                                // Drive the animation by preparing to paint the next frame
                                // after this one is shown.
-                               a.Send(paint.Event{})
+                               //a.Send(paint.Event{})
                        case touch.Event:
                                touchX = e.X
                                touchY = e.Y
```
Repository: rust
Issue: Error messages about lifetimes for mutable Iterator are cryptic.
Labels: C-enhancement,A-diagnostics,A-lifetimes,T-compiler

Example: http://is.gd/8dVXWc

```
<anon>:42:14: 42:33 error: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
<anon>:42         Some(&mut self.cont.item)
                       ^~~~~~~~~~~~~~~~~~~
<anon>:39:5: 43:6 help: consider using an explicit lifetime parameter as shown: fn next(&'a mut self) -> Option<&'a mut V>
<anon>:39     fn next(&mut self) -> Option<&'a mut V> {
<anon>:40         if self.emitted { return None }
<anon>:41         self.emitted = true;
<anon>:42         Some(&mut self.cont.item)
<anon>:43     }
error: aborting due to previous error
playpen: application terminated with error code 101

Compilation failed.
```

@bluss gave me a [helpful link](http://stackoverflow.com/a/25748645) on IRC, stating that is a classic thing.

I think for every "classic" problem there should be a lint giving a link to some article about the problem.

In this case the link can be emitted for any lifetimes problem when mutable references and `Iterator` trait involved together.

For reference: [link](http://is.gd/uZj9DI) to changed version that does compile.
Repository: go
Issue: net: add support for FileConn, FilePacketConn, FileListener on Plan 9
Labels: OS-Plan9,FeatureRequest

A new test reveals that Plan 9 doesn't support File{Conn,Listener,PacketConn}.

```
--- FAIL: TestFileConn (0.00s)
    file_test.go:121: write tcp 127.0.0.1:58090: write /net/tcp/26/data: i/o on hungup channel
FAIL
```

Just FYI: https://storage.googleapis.com/go-build-log/b7d5a4b1/plan9-386_d2e48151.log
Repository: angular
Issue: Handling of "<" in html
Labels: type: bug/fix,area: compiler,P3,compiler: parser,feature: votes required

#5657 allows "<" in text nodes so that `<p>{{ a < b ? c : d }}</p>` does not throw.

However this is not valid html  - `<` would have to be `&lt;` to have a valid html.

One potential issue with the current approach is that in `<p>{{ a <b && c >  d }}</p>` `<b && c >` would be parsed as an html tag and would not be easy for user to debug.

We could solve this by making the lexer aware of angular expression.

/cc @tbosch 

edit `{{ "<b>text</b>" }}` could also cause pb
Repository: flutter
Issue: Drop downs and popup menus have opposite material bugs
Labels: framework,a: animation,f: material design,a: quality,P3,team-design,triaged-design

You can't interact with an item on a popup menus before it has finished animating in.

You _can_ interact with an item in a drop down menu, but doing so will draw ink splashes in the air before the material has painted there.

We should come up with a rationalisation that solves both these problems cleanly.
Repository: go
Issue: x/net/websocket: ErrBadStatus should include the bad status code
Labels: NeedsInvestigation

Right now, if a `x/net/websocket` client connects to an HTTP endpoint and receives a response with any status other than 101, it returns an `ErrBadStatus` ([source](https://github.com/golang/net/blob/01256db42e5106196a3473ec1620727a383500e8/websocket/hybi.go#L448)).  This error does not include the actual status code received, and so users of this library are unable to distinguish between, for instance, 403 Forbidden and 500 Internal Server Error responses.

One solution would be to add a `websocket.HTTPStatusError` which implements `websocket.ProtocolError` and also includes an exported `Status` field.  This way, users could (if they wished) check the type of the error and switch on the `Status` field to determine correct behavior.
Repository: go
Issue: tour: better explanation about type declarations?
Labels: Documentation,NeedsInvestigation

Context: https://tour.golang.org/moretypes/2

I just decided to look through the Go tour to see how it explains named types and assignability.  As far as I can tell, the only explanation is the parenthetical sentence "And a `type` declaration does what you'd expect."

Based on user questions like issue #13529, I suspect that `type` declarations do _not_ necessarily do what users expect, and perhaps it's worth elaborating on this point somehow.
Repository: neovim
Issue: :colorscheme - no syntax highlighting when changing colorscheme
Labels: bug-vim

Start with a colorscheme - like monokai, all tags are highlighted, everything works.
![2015-12-08-210804_406x246_scrot](https://cloud.githubusercontent.com/assets/7141867/11659850/5d23fc08-9df0-11e5-91e0-64ca35566213.png)

Now change to a heavier colorscheme - one which defines more syntax rules (like solarized or PaperColor). 
![1](https://cloud.githubusercontent.com/assets/7141867/11659864/66c142de-9df0-11e5-94cd-403152c588d5.png)
Everything still works.

Now switch back to the 'lighter' colorscheme (in this case monokai) - very few tags are highlighted. Even strings are not highlighted properly.
![3](https://cloud.githubusercontent.com/assets/7141867/11659870/6dfce972-9df0-11e5-873c-8afe353f98d7.png)

On further digging, I found an [old stackoverflow link](http://stackoverflow.com/questions/12915797/gvim-remove-syntax-highlighting-groups).
There @xolox gave an explanation to this problem and a possible solution.

Can this problem be solved ?
If not, can :colorscheme be remapped to some function like `xolox#colorscheme_switcher#switch_to()` from [xolox/vim-colorscheme-switcher](https://github.com/xolox/vim-colorscheme-switcher) ?
Repository: youtube-dl
Issue: abort video + audio when --max-filesize reached
Labels: request

```
youtube-dl -f bestvideo[ext=mp4]+bestaudio[ext=m4a]/best --max-filesize 2G --abort-on-error 'https://www.youtube.com/watch?v=ksWHFG8-gC4'
```

When i exec this command for a youtube video, if the video file is bigger than 2G, video download is aborted, but audio file is still downloaded.

is there any option combination that would abort download totally (video and audio)?
Repository: TypeScript
Issue: Automatically inserting JSX closing element in TypeScript JSX file
Labels: Suggestion,Visual Studio

Currently, when users type non self-closing JSX tag, they will have to type corresponding closing JSX tag. In this situation, our language service can help the users by automatically insert the corresponding JSX tag. The newly inserted tag should respect existing format and If the matching closing tag exists, the closing tag should not be insert. 

``` ts
var x = <div> [insert by language-service] </div>
var y =
<div>
[insert by language-service]</div>
var z = 
    <div>
     [insert by language-service] </div>
```
Repository: kubernetes
Issue: Handle node label updates and deletions
Labels: sig/node,kind/feature,priority/important-longterm,lifecycle/frozen,needs-triage

As of now node labels can be updated either via the API server directly or through the kubelet.
Inside of the kubelet, labels can be set directly from inside of kubelet, or by using command line flags and localhost files.

Ownership of labels is not explicit. As of now a label set via the kubelet can be updated through the API server directly. If the kubelet restarts, it will update those labels again. 

Kubernetes does not specify any policy around label source precedence. 
To begin with we can require users to avoid label key conflicts themselves. 

We need to fix label ownership though. 

Kubelet should be aware of the labels that it has created. It should not update or delete labels that were not originally created through the kubelet. Kubelet needs to keep track of all the labels it has added and delete any labels that were removed across restarts. 

In v1.1, the kubelet did not surface any labels. hence forwards and backwards compatibility should not be an issue.

Related issues & PRs: #17265, #17575, #13524
Repository: TypeScript
Issue: Differing user-defined type guard and 'typeof' type guard behaviour when narrowing 'any'
Labels: Suggestion,Help Wanted,Effort: Moderate

In the below code, using a typeof type guard and an equivalent (I thought) user-defined guard, only one error is produced.

``` typescript
var y: any;

// Built-in type guard
if (typeof y === "string") {
    y.hello = true; // Correct error - 'hello' does not exist on type string
}

// Equivalent user-defined type guard
function f(x: any): x is string {
    return typeof x === "string";
}

if (f(y)) {
    y.hello = true; // No error with user-defined guard
}
```

[Playground demo](http://www.typescriptlang.org/Playground#src=var%20y%3A%20any%3B%0A%0A%2F%2F%20Built-in%20type%20guard%0Aif%20%28typeof%20y%20%3D%3D%3D%20%22string%22%29%20%7B%0A%09y.hello%20%3D%20true%3B%20%2F%2F%20Correct%20error%0A%7D%0A%0A%2F%2F%20Equivalent%20user-defined%20type%20guard%0Afunction%20f%28x%3A%20any%29%3A%20x%20is%20string%20%7B%0A%09return%20typeof%20x%20%3D%3D%3D%20%22string%22%3B%0A%7D%0A%0Aif%20%28f%28y%29%29%20%7B%0A%09y.hello%20%3D%20true%3B%20%2F%2F%20No%20error%20with%20user-defined%20guard%0A%7D). Looks like user-defined type guards won't narrow from `any`, in any circumstances, as far as I can tell.
Repository: go
Issue: cmd/compile: escape analysis overconservative for recursive calls
Labels: NeedsFix,compiler/runtime

Sample program.  Allocation in inner loop of recursive foo does not escape, but conservative assumptions (because escape analysis does not do fixed-pointer iteration) force conclusion that it does.

```
package main
// import "fmt"
type Node struct {
    next *Node
    name string
}
var sink string
func foo(list *Node, names []string) {
    if len(names) > 0 {
        name := names[0]
        for i := 0; i < len(name); i++ {
            foo(&Node{list, name[i : i+1]}, names[1:]) // need not escape
        }
    } else if list != nil {
        // fmt.Printf("%s", list.name) // you don't want to to do this unless you are comparing output.
        sink = list.name
        foo(list.next, names)
    }
}
func main() {
    names := []string{"ant", "bat", "cat", "dog", "emu",
        "fox", "gnu", "hyena", "iguana", "jaguar"}
    foo(nil, names)
}
```
Repository: youtube-dl
Issue: Site Support Request: serviporno.com
Labels: site-support-request

Hi,
Another popular site:
./youtube-dl http://www.serviporno.com/videos/adolescente-cenida-y-su-maquina-de-follar/
[generic] adolescente-cenida-y-su-maquina-de-follar: Requesting header
WARNING: Falling back on generic information extractor.
[generic] adolescente-cenida-y-su-maquina-de-follar: Downloading webpage
[generic] adolescente-cenida-y-su-maquina-de-follar: Extracting information
ERROR: Unsupported URL: http://www.serviporno.com/videos/adolescente-cenida-y-su-maquina-de-follar/

thanks...
Repository: kubernetes
Issue: Rolling updates should fail early if a pod fails to start
Labels: priority/backlog,area/app-lifecycle,area/workload-api/deployment,sig/apps,lifecycle/frozen

In 1.0.x, rolling update didn't block, so we could check things like a failed pod while waiting for the update to complete.

In 1.1.x, rolling update does block up to the timeout amount. This is great since we had to script it externally before. However it waits the entire timeout even if the update fails immediately. For instance, if you specify a non-existent image the pod will report a `PullImageError`. At that point the rolling update could abort immediately. Instead it blocks for the 5 minute timeout. When frequently developing and deploying this 5 minute timeout becomes painful.

I suggest rolling-update fails immediately if any of the new pods are not in a 'Pending' or 'Running' state. Not sure if there is a set of non-error states we can use.
Repository: TypeScript
Issue: is there a way to narrow down the amount of information that goes to the member info tooltip of intellisense?
Labels: Suggestion,Help Wanted,Effort: Moderate,Domain: Quick Info

Namely, is there a way to opt out from seeing:
- union/intersection type constituens
- members of a type alias referring to an anonymous product type?

![img_11122015_142244](https://cloud.githubusercontent.com/assets/937933/11753625/2650bf74-a014-11e5-8237-9e0db8857922.png)