sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: flutter
Issue: `flutter doctor` has strange adb message (even though I'm not running anything)
Labels: platform-android,tool,t: flutter doctor,P2,team-android,triaged-android

I don't have Android Studio installed, nor any Android devices connected.

```
Framework • revision 10decc7c19 (27 hours ago) • 2017-05-16 21:30:46 -0700
Engine • revision 6fef702cfa
Tools • Dart 1.23.0-dev.11.11

Running "flutter packages upgrade" in posse_gallery...  7.7s

Running flutter doctor...
[✓] Flutter (on Mac OS X 10.12.4 16E195, channel master)
    • Flutter at /src/flutter
    • Framework revision 10decc7c19 (27 hours ago), 2017-05-16 21:30:46 -0700
    • Engine revision 6fef702cfa
    • Tools Dart version 1.23.0-dev.11.11

[✗] Android toolchain - develop for Android devices
    ✗ Unable to locate Android SDK.
      Install Android Studio from: https://developer.android.com/studio/index.html
      On first launch it will assist you in installing the Android SDK components.
      (or visit https://flutter.io/setup/#android-setup for detailed instructions).
      If Android SDK has been installed to a custom location, set $ANDROID_HOME to that location.

[✓] iOS toolchain - develop for iOS devices (Xcode 8.3.2)
    • Xcode at /Applications/Xcode.app/Contents/Developer
    • Xcode 8.3.2, Build version 8E2002
    • ios-deploy 1.9.1
    • CocoaPods version 1.2.1

[✗] Android Studio (not installed)
    • Android Studio not found. Download from https://developer.android.com/studio/index.html
      (or visit https://flutter.io/setup/#android-setup for detailed instructions).

adb server version (38) doesn't match this client (39); killing...
[✓] Connected devices
    • Eric's iPhone • 245efaebda74df40169418839fff2a8368bcaae5 • ios • iOS 10.3.1 (14E304)
```
Repository: TypeScript
Issue: Plugins - support a 'willSave' hook
Labels: Suggestion,Awaiting More Feedback

Background angelozerr/tslint-language-service#32.

The tslint language server extension should support an option to auto fix lint rules with a fixer before a file is saved. The plugin API should support a willSave method that a plugin can use to perform an operation like auto fixing before the document is saved. In addition there needs to be request that the TypeScript language client like VS Code can use to inform the TypeScript language server that the user is about to save a file.
Repository: rust
Issue: rustdoc: disambiguate between types of the same name
Labels: T-rustdoc,C-enhancement

As an extension to #38414 and #39589, any hyperlinked reference to some type should be checked against everything within that crate - within any dependent crate too, if possible. This will help clear the confusion between the perennial problem types in std, `std::result::Result` and `std::io::Result` (and to a lesser extent, `std::io::Write` and `std::fmt::Write`).

Some before/after screenshots made with chrome's inspector with what I have in mind:

![Write for String](https://cloud.githubusercontent.com/assets/5217170/26168430/a47f6148-3aff-11e7-8952-2e631c064ffb.png)

![File::create -> Result](https://cloud.githubusercontent.com/assets/5217170/26168525/f73fc274-3aff-11e7-9c69-181fbd2995ca.png)
Repository: go
Issue: doc: add screencast to docs
Labels: Documentation,NeedsInvestigation,DevExp

This is a tracking bug to add screencasts to the docs. 

A brief draft of the content we want to cover with the screencasts, these are not sorted by priority at this moment - please contribute to the discussion of prioritization:
 
- Installation
  - Platform dependent
- Environment set-up
  - Platform dependent
  - GOPATH / src/pkg/bin etc
  - go version
  - go help
- Writing "Hello, world!"
  - Where does it go?
  - Editors, plugins, etc (link to them)
  - Importing packages in the std lib / How to access documentation? golang.org/pkg/
  - go install/run/build
- Writing your first library
  - Package names and how to import them
  - Documentation
- Using non stdlib packages
  - Importing non stdlib packages
  - go get (-u)
- Testing
  - go test
  - Code coverage
- Managing your GOPATH
  - go list
  - Folder structure
  - Multiple GOPATHs
- Managing dependencies
  - Vendoring?
  - Versioning? Semver
- Contributing to GitHub repos
  - Forks and PRs
- Contributing to the Go project
  - Set up
  - Gerrit
  - Contributing guidelines
- Debugging
- Performance profiling
  - Benchmarks
  - Load testing
  - Pprof
  - Flame Graphs
- Execution tracer

Constraints on videos:
- Platform dependent steps should be contained into different video variations
- Videos should be short (target ~2 minutes, absolute max 5 minutes)
- Each video should mirror a specific document, to improve cross linking

/cc @campoy @goinggo @jessfraz
Repository: vscode
Issue: See git diff of two files in horizontal layout
Labels: feature-request,diff-editor

I followed the thread of impementing horizontal window splitting, thank you for that.

I don't seem to be able to achieve the same effect with the git diff view:

![image](https://cloud.githubusercontent.com/assets/8936090/26190163/535845a6-3ba8-11e7-99b8-c65047c9987d.png)

Am I missing something? I know there's a toggle inline diff, but that's not the solution.

If it's not implemented I think it should be, for the same reasons.
Repository: opencv
Issue: cudaDeviceSynchronize() affects multi-thread CUDA performance
Labels: bug,category: gpu/cuda (contrib)

##### System information (version)
- OpenCV => any version (with CUDA support)
- Operating System / Platform => any platform (with Nvidia Graphics Card)
- Compiler => any cuda compiler

##### Detailed description

Here are some codes in functions that support `cv::cuda::Stream`:
```cpp
if (stream == 0)
    CV_CUDEV_SAFE_CALL( cudaDeviceSynchronize() );
```
If I use CUDA kernel in only one thread on a card, these codes work fine.  
However, if I have two threads on a card, one (call it thread A) uses default stream (or do not specify a stream explicitly), and another one (thread B) uses a different stream, it causes problem.  
Thread A will call `cudaDeviceSynchronize()` and it will synchronize the whole device rather than the default stream. So kernels on thread B will be synchronized too, and so thread A will wait for completion of thread B, which may cause serious performance problem.
In fact, it's safe to call `cudaStreamSynchronize(stream)` even if `stream == 0`. According to CUDA document, `cudaStreamSynchronize` will safely synchronize the default stream if `stream == 0`.
Is it possible to replace all `cudaDeviceSynchronize` in OpenCV ? Thanks.

##### Steps to reproduce
Use two threads in program, one uses default stream and one uses another stream.
```cpp
// Some function definitions on different threads.
void f1(cv::cuda::GpuMat & lhs, cv::cuda::GpuMat & rhs) {
    cv::cuda::transpose(lhs, rhs);
}

void f2(cv::cuda::GpuMat & lhs, cv::cuda::GpuMat & rhs, cv::cuda::Stream &_stream) {
    cv::cuda::transpose(lhs, rhs, stream);
}
cv::cuda::GpuMat a, b, c, d;
/* ... some other codes ... */
std::thread t1(f1, a, b);
std::thread t2(f2, c, d);

```
Repository: opencv
Issue: cuda::reprojectImageTo3D does not handle missing values
Labels: feature,category: gpu/cuda (contrib)

In the CPU version of `reprojectImageTo3D` there is an option to ignore (or handle) pixels where no disparity was calculated (giving them, for example, an enormous Z-value). This is useful for quick filtering of the output point cloud.

There is no such option in the CUDA version, but it should be fairly trivial to implement. I'm happy to have a crack at this, if a new function signature can be agreed. Currently:

    cuda::reprojectImageTo3D(InputArray disp, OutputArray xyzw, InputArray Q, int dst_cn=4, Stream& stream=Stream::Null())

We could add an overload to keep it similar to the CPU version:

    cuda::reprojectImageTo3D(InputArray disp, OutputArray xyzw, InputArray Q, int HandleMissing=0, int dst_cn=4, Stream& stream=Stream::Null())
Repository: go
Issue: cmd/compile: improve loop rotation
Labels: Performance,compiler/runtime

This is a follow-on to #20355 for the 1.10 cycle. See CL 43491 for more discussion of these points.

* Should we work from innermost loops out?
* Do we want to move contained loops?
* Do we want to reinstate some form of loop skipping?
* Other improvements?

See also #18977 and #20356.

cc @randall77 @dr2chase @cherrymui
Repository: go
Issue: x/build: mention notable benchmark changes in Gerrit comment
Labels: Builders

I think it's going to be too easy to miss significant benchmark changes with the current state of things where the URL to perf.golang.org is always included in the final Gerrit comment.

I think the gerrit comment should also mention any notable changes.

/cc @quentinmit @josharian
Repository: pytorch
Issue: Pad PackedSequences to original batch length
Labels: hackamonth,triaged,module: nestedtensor

The current flow for handling variable length sequences in RNNs is:

```python
packed_input = torch.nn.utils.rnn.pack_padded_sequence(input, lengths)
packed_output = rnn(packed)[0]
output = torch.nn.utils.rnn.pad_packed_sequence(packed_output)
```

The output size of the Variable returned by pad_packed_sequence is determined by the max length in lengths: https://github.com/pytorch/pytorch/blob/master/torch/nn/utils/rnn.py#L106.

However, this only works in recovering the original size of the input if the max length sequence has no padding (max length == length dim of batched input). For normal, sensible batching this makes sense and should be true.

But if a model is using, say, DataParallel, the batch might be split such that there __is__ extra padding. And the output size from the RNN will be truncated (which might break other things down-stream).

To fix this potentially unexpected behavior, I propose two possible simple patches.

1) A `max_batch_size` field is calculated from the original input and added to the PackedSequence namedtuple: https://github.com/pytorch/pytorch/blob/master/torch/nn/utils/rnn.py#L6 and used instead of https://github.com/pytorch/pytorch/blob/master/torch/nn/utils/rnn.py#L106

2) An optional `max_batch_size` parameter is added to pad_packed_sequence which would be used as an override.

I prefer 1), but I suppose 2) has the advantage of being fully backwards compatible (even though it is discouraged to be directly creating or meddling with PackedSequence tuples, it is possible).

cc @cpuhrsch
Repository: go
Issue: crypto/tls: customisable max TLS record size
Labels: Proposal-Accepted,NeedsFix,Proposal-Crypto

Hi,

The default TLS record/chunk size is 16kB - and this is what golang uses (`maxPlaintext` in crypto/tls/common.go I think).

It would be useful if the max TLS record size was customisable via `Config`.

Use-case is we have memory restricted embedded devices (running mbed TLS) talking TLS to a golang server. The client TLS (receive) buffer needs - in our case - to be less than 16kB to fit in memory - and the server and the client has to agree on this max size.

For mbed TLS this is customisable using `MBEDTLS_SSL_MAX_CONTENT_LEN`.
Repository: TypeScript
Issue: module: "system" and outFile generates wrong module names
Labels: Bug

<!-- BUGS: Please use this template. -->
<!-- QUESTIONS: This is not a general support forum! Ask Qs at http://stackoverflow.com/questions/tagged/typescript -->
<!-- SUGGESTIONS: See https://github.com/Microsoft/TypeScript-wiki/blob/master/Writing-Good-Design-Proposals.md -->

**TypeScript Version:** 2.4.0-dev.20170519

**Code**

this Typescript code (on the main project)

```ts
'use strict'

import { createStore, applyMiddleware, combineReducers } from 'redux'
import { routerReducer, LOCATION_CHANGE } from 'react-router-redux'
import { handleActions, Action } from 'redux-actions'
import { Login, Data, Groups } from 'cim-typings'
import { Initials } from 'cim-shared-ui/helpers'
import * as RActions from './actions'
```

generates

```js
System.register("reducers", ["redux", "react-router-redux", "redux-actions", "../../cim-shared-ui/helpers", "actions"], function (exports_2, context_2) {
/* ... */
})
```

which is wrong. "../../cim-shared-ui" should be "cim-shared-ui", because it's a `npm linked` package. not sure if the problem is the link itself, because I have this, and works correctly, which is also from the main project:

```ts
'use strict'

import React from 'react'
import { Data } from 'cim-typings'
```

```js
System.register("components/status", ["react", "cim-typings"], function (exports_5, context_5) {
/* ... */
})
```

tsconfig.json as follows:

```json
{
  "exclude": [
    "./node_modules",
    "./jspm_packages",
    "./dist"
  ],
  "include": [
    "./generic.d.ts",
    "src/*.ts",
    "src/*.tsx",
    "src/**/*.tsx",
    "src/**/*.ts"
  ],
  "compilerOptions": {
    "module": "system",
    "jsx": "react",
    "target": "es5",
    "moduleResolution": "node",
    "allowSyntheticDefaultImports": true,
    "rootDir": "src",
    "newLine": "LF",
    "allowJs": false,
    "noImplicitAny": true,
    "baseUrl": "./",
    "noEmitOnError": true,
    "sourceMap": true,
    "alwaysStrict": true,
    "inlineSourceMap": false,
    "paths": {
      "*": [
        "node_modules/@types/*",
        "*"
      ]
    },
    "lib": [
      "dom",
      "es2015",
      "es5"
    ],
    "outFile": "dist/app.js"
  }
}
```

**Expected behavior:**

module: "system" should output dependencies as authored

**Actual behavior:**

TS is trying to do something funny with the paths, and it's inconsistent with other npm linked packages. The only difference between the two is that `cim-typings` is a `commonjs` module, and `cim-shared-ui` is a `system` module
Repository: youtube-dl
Issue: SITE REQUEST: pruffme.com webinars live video downloads
Labels: site-support-request

Hello dearest coders.
I want to ask you to code this pruffme.com site into YDL so it will get live feed to one .mp4 file, or what video format it has. The log:
R:\>youtube-dl.exe -F -v https://pruffme.com/a1eae7cd-662c-4938-9d19-2448fb34db0d
[debug] System config: []
[debug] User config: []
[debug] Custom config: []
[debug] Command-line args: ['-F', '-v', 'https://pruffme.com/a1eae7cd-662c-4938-9d19-2448fb34db0d']
[debug] Encodings: locale cp1251, fs mbcs, out cp866, pref cp1251
[debug] youtube-dl version 2017.05.18.1
[debug] Python version 3.4.4 - Windows-7-6.1.7601-SP1
[debug] exe versions: ffmpeg 3.2.4, ffprobe 3.2.4, rtmpdump 2.4
[debug] Proxy map: {}
[generic] a1eae7cd-662c-4938-9d19-2448fb34db0d: Requesting header
WARNING: Falling back on generic information extractor.
[generic] a1eae7cd-662c-4938-9d19-2448fb34db0d: Downloading webpage
[generic] a1eae7cd-662c-4938-9d19-2448fb34db0d: Extracting information
ERROR: Unsupported URL: https://pruffme.com/a1eae7cd-662c-4938-9d19-2448fb34db0d
Traceback (most recent call last):
  File "C:\Users\dst\AppData\Roaming\Build archive\youtube-dl\rg3\tmpwgfs80it\build\youtube_dl\YoutubeDL.py", line 760,in extract_info
  File "C:\Users\dst\AppData\Roaming\Build archive\youtube-dl\rg3\tmpwgfs80it\build\youtube_dl\extractor\common.py", line 433, in extract
  File "C:\Users\dst\AppData\Roaming\Build archive\youtube-dl\rg3\tmpwgfs80it\build\youtube_dl\extractor\generic.py", line 2795, in _real_extract
youtube_dl.utils.UnsupportedError: Unsupported URL: https://pruffme.com/a1eae7cd-662c-4938-9d19-2448fb34db0d

This video feed will be online for 3 hours only since 19:20 UTC+03 (22 minutes already passed), so - if you can, please take a look at that flash video url ASAP!:)

Thanks in advance!!!
Repository: electron
Issue: Provide ffmpeg.so file that plays all common videos
Labels: enhancement :sparkles:

Hey, I have been struggling with playing more than the few video codecs supported by electron by default. There are dozens of GitHub issues and posts somewhere else of people like me who are trying to get decent video support in electron. If I understand this correctly, the main issue is licensing. It's possible to compile electron with extended video support but that would require the project built with this to be licensed as some form of GPL. For my project ideas and those of others, this is not a problem as we would gladly contribute to the open source scene. However, I have failed many times to compile Electron myself and when you search the internet others have struggled with this too. 

I would really appreciate if the official maintainers could provide us with an `ffmpeg.so` file that supports all or most of the common video codecs. Oh the great stuff we could build with this.

PS: I know that there is [WebChimera](http://www.webchimera.org/), but the maintainer is struggling with support for newer versions as VLC closes their APIs. Also, this is more of a hack and a "native" solution would be much much nicer.
Repository: create-react-app
Issue: Add Travis test with empty NODE_PATH
Labels: contributions: up for grabs!,tag: internal,difficulty: medium

Since Travis tests run with `NODE_PATH` specified, it doesn't catch issues in code that does something wrong on empty `NODE_PATH`. We should add end-to-end tests for starting, building, and running tests with empty `NODE_PATH`.
Repository: go
Issue: x/exp/shiny: allow bounded types for Deque
Labels: NeedsInvestigation

Calls to window.NextEvent() and the processing of the returned event all happen in the same goroutine. For paint and size events, this can cause Deque to congest with stale events.

Given the generic nature of type Deque, one method of addressing this is to allow declaring certain event types to be bounded, in that only N instances of the given type are ever allowed to exist and for simplicity let's say N=1.

In a shiny application, I only ever care about the last size and paint events, but I don't think it's appropriate to fuss over those details during any sort of iteration. If I declare a package level event, I might also want to tell Deque to only store N=1 instances.

To address this in an example program I wrote, I copy/pasted widget.RunWindow and inserted a small FIFO that exhausts Deque in a goroutine but only ever stores one instance of size and paint:

https://github.com/dskinner/x/blob/01a0257ede3a13250b22e5328097aa9d1a6911f5/glw/example/glwidget/main.go#L207

The above isn't done at great effort as the size and paint events only fire when que is empty. A second implementation tracked what would have been que insert index and on NextEvent, checked each bound type if insert index is zero or decremented, finally delivering an event from que if no bounded was sent (but this was just an example program so I removed this).

Providing some sort of `func (q *Deque) BoundType(T)` for the simple case of N=1 has a couple ramifications/questions:

* This is no longer exactly a "Deque" as we'd begin dividing into buckets. I don't know if there's a bucket (or otherwise) queue type out there that already addresses what I'm raising, but I'd like to research that or get feedback on that before committing to any sort of proposal.

* For the specific case I'm suggesting above where only the last event of a given type is ever stored, it is, I suppose, theoretically possible to never receive that event given the right sequence of events if each event takes its rightful place based on its original insert index (and not replace the first instance which would negate this). Regardless, I don't feel it's appropriate to replace the first instance with the last and I'm not sure I really consider this case a practical concern.

Any feedback and/or thoughts for intention of Deque welcomed.

@nigeltao
Repository: flutter
Issue: Shadow under Shrine app bar is darker than YouTube app bar shadow
Labels: framework,f: material design,a: fidelity,P2,team-design,triaged-design

Brought up by someone on Twitter. Here's a screenshot:
![screenshot_20170520-233414](https://cloud.githubusercontent.com/assets/5479/26281735/2eb4a7da-3db5-11e7-83fb-ec3811a1f559.png)
Repository: go
Issue: proposal: spec: add read-only slices and maps as function arguments
Labels: LanguageChange,Proposal,LanguageChangeReview

Background
---
I recently stumbled upon a bug and after hours of searching, I managed to find the culprit, which is a function that accidentally modifies the slice argument passed to it. The problem is that as I took several subsets of the original slice and gave them new identities, I forgot that they were still pointing to the original slice. I don't think this is an uncommon issue, and hence the proposal below.

Proposal
---
I would like to suggest the idea of defining a read-only slice and map in the function arguments. For example, we can define a function as follows:

//function definition
func MyFunction(const mySlice []byte, const myMap map[string][]byte) []byte

//usage
mySlice := []byte {0x00, 0x01} //normal slice definition. There is no weird _const_ whatsoever.
myMap := make(map[string][]byte) //normal map definition.

//you are still using slice and map as you normally would. Slice and map are still modifiable, 
//but MyFunction cannot alter the original variables.
MyFunction(mySlice, myMap) 

//you can still make changes here
myMap["Me"] = 0x01

or in the interface definition:

`type MyInterface {
    MyFunction(const mySlice []byte) []byte
}`

Why slices and maps?
---
With structs, interfaces and built-in types, it is easy to tell whether you want them to be modifiable or not. With slices and maps, it is not so easy to tell. Maps are probably less prone to accidental changes, but slices are tricky, especially when they get passed around many functions.

Implementation Options
---
Read-only slices and maps are shallow-copied upon being passed to the function. Hence, any accidental change is local to the function. I understand that this will not prevent interior mutability, but exterior mutability is good enough. I think this implementation option is probably less intrusive and there are fewer breaking changes to existing codes (if any) - possibly none.

Alternatively, we may have a more elaborate system where the compiler will not compile if a function tries to modify a read-only slice/map. However, this leads to a very complex solution. What if a new sub-slice is taken from an existing read-only slice, should it be immutable too?  Now, what if that sub-slice is passed into another function, should the compiler check whether the other function preserves the integrity of the sub-slice? 

I personally tend to lean with the first option.   

Syntax
---
In order not to add any new keyword, I am thinking of reusing _const_, and it is also more intuitive to those familiar with C-family programming languages. However, I am open to suggestions.

---

Let me know what you think.

Thanks