Menéame: comentarios [2628612]

#94 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

JoePerkins — Tue, 14 Jun 2016 12:01:24 +0000

Justo estoy empezando a aprender C++. Por cierto, muy gratamente sorprendido con la IDE del Visual Studio, me esperaba una ranciada. Claro que a nivel de funcionalidades aún no lo he manejado apenas.

Aunque casi que al leer el meneo se me están quitando las ganas de usarlo .

» autor: JoePerkins

#93 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--514899-- — Mon, 13 Jun 2016 10:45:56 +0000

#92 si le das a aceptar a todo sin leer al instalar windows es tu problema, yo lo tengo desactivado y windows 10 te pregunta cuando lo instalas y no hablo de la licencia si no de las opciones de privacidad.
Mozilla Firefox también manda telemetría por defecto, seguro que lo han hecho con el visual estudio.
Google no te pregunta nada al instalar el chrome, te mete un proceso programado para reactivarse soloo aunque tu lo borres del inicio y yo no veo a nadie quejándose tanto

» autor: --514899--

#92 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

nodearth — Mon, 13 Jun 2016 09:10:36 +0000

#73 No entiendo pq tengo que desactivar algo que no he pedido .

» autor: nodearth

#91 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--151960-- — Sat, 11 Jun 2016 10:37:19 +0000

[Usuario deshabilitado]

» autor: --151960--

#90 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Pentium-ll — Sat, 11 Jun 2016 09:45:53 +0000

#12 Buen discurso, pero deberías haberlo rematado con algún enlace de este tipo: www.fsf.org/es/about

Y también tendrías que haber dicho "malévolo" en referencia al software privativo como hace nuestro querido Stallman, al que también algunos le pusieron el gorro de aluminio hace tiempo pero al final va a ser el que tiene toda la puta razón.

» autor: Pentium-ll

#89 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--450592-- — Sat, 11 Jun 2016 08:55:17 +0000

#31 Los que me han votado negativo este comentario no tiene ni idea de como funciona un compilador.

» autor: --450592--

#88 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--143520-- — Sat, 11 Jun 2016 08:19:14 +0000

#9 Si una aplicación que has programado se comporta como esperabas es la misma mierda que leer un libro que has escrito tu, ya lo conoces, y tienes todos los spoilers posibles. Ni vale la pena.

» autor: --143520--

#87 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--143520-- — Sat, 11 Jun 2016 08:17:31 +0000

#75 Tampoco se trata de que importe el para qué, desde el momento que modificas el código sin autorización para un servicio tuyo, ya está siendo desleal. En el momento que decides que meter chorradas de estas es algo que puedes hacer, dar el siguiente paso es simplemente un cambio cuantitativo. (No deja de ser diferente a lo que pasa con los sitios web, en un principio solo contaban visitas, quizás tu ip, ahora hasta te ponen cookies para rastrearte en cualquier sitio que visitas últimamente la tendencia en cualquier tecnología de la información es recopilar datos simplemente porque puedo)

Además, en mi opinión las opciones por defecto deberían ser siempre las menos impositivas.

» autor: --143520--

#86 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--143520-- — Sat, 11 Jun 2016 08:13:59 +0000

#19 Y no solo será eficiente, sino que tendremos garantías de que lo es.

» autor: --143520--

#85 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--51656-- — Sat, 11 Jun 2016 06:57:01 +0000

#6 "what the code does is trigger an ETW event which, when it’s turned on, will emit timestamps and module loads events. The event data can only be interpreted if a customer gives us symbol information (i.e. PDBs) so this data is only applicable to customers that are actively seeking help from us and are willing to share these PDBs as part of their investigation."

Al final #2 va a tener razón

» autor: --51656--

#84 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ccguy — Sat, 11 Jun 2016 05:10:50 +0000

#75 A ver, si un usuario de mi programa tiene un problema debe hablar conmigo, no con microsoft (que desde luego no le va a dar ningún soporte útil) y mucho menos mandarles un fichero que puede contener información muy delicada.

Desde luego cuando yo hago un programa lo que menos espero es que si hay problemas el usuario se ponga en contacto con el fabricante del compilador (¿?) y mucho menos que el binario tenga información que permita a una tercera parte conocer valores de variables y cosas así.

Perdona pero de momento voy a seguir con mi gorro porque parece muy necesario.

» autor: ccguy

#83 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Hopo — Fri, 10 Jun 2016 23:17:56 +0000

#59 #49 gracias a clang gcc se ha puesto las pilas en mejorar el otput de errores.
Kudos para clang.

Por cierto si gcc te parece lento, prueba nvcc (con template kernels y múltiples arquitecturas)

» autor: Hopo

#82 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--193560-- — Fri, 10 Jun 2016 23:15:06 +0000

#79 claro, usar RAII es un estilo, el bueno. No usar RAII es otro estilo, el malo. Está claro que puedes hacer las cosas bien o las puedes hacer mal, pero eso independientes entre del lenguaje.
Si lanzas excepciones en los destructores es otra cosa que estás haciendo mal.

» autor: --193560--

#81 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--334312-- — Fri, 10 Jun 2016 22:38:54 +0000

[Usuario deshabilitado]

» autor: --334312--

#80 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Wayfarer — Fri, 10 Jun 2016 22:26:16 +0000

#9 ...eso, las que llegan a ejecutarse.

» autor: Wayfarer

#79 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

alephespoco — Fri, 10 Jun 2016 22:22:40 +0000

#63 RAII es un estilo de programación y C++ no te obliga a funcionar de ese modo (puedes funcionar perfectamente con new y delete).
Otra cosa es que RAII sea recomendable, pero también tiene sus inconvenientes como que dé una excepción en un destructor.

» autor: alephespoco

#78 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

animalDeBellota — Fri, 10 Jun 2016 22:02:57 +0000

#75 las justificaciones son de risa. Les han pillado con el carrito del helado... y ahora reculan.

www.reddit.com/r/cpp/comments/4ibauu/visual_studio_adding_telemetry_fu

» autor: animalDeBellota

#77 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--27313-- — Fri, 10 Jun 2016 22:02:17 +0000

#45 GRACIAS

» autor: --27313--

#76 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--514899-- — Fri, 10 Jun 2016 21:53:06 +0000

#74 no. El programa lanza un triger que es ignorado por el sistema operativo porque no está escuchando al estar desactivada. Así muy simplificado

» autor: --514899--

#75 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--27313-- — Fri, 10 Jun 2016 21:51:10 +0000

#3 Vamos a ver, tranquilidad que te veo muy exaltado. Según este hilo de reddit,

www.reddit.com/r/cpp/comments/4ibauu/visual_studio_adding_telemetry_fu

donde el propio director de desarrollo de Visual C++ responde directamente a las acusaciones, deja claro que sólo se logea cuando se inicia y finaliza el programa y cuándo se cargan módulos, todo ello como herramienta de monitorización en el caso de que un usuario decidiese solicitar ayuda a microsoft para evaluar problemas de rendimiento. Y por lo que algunos usuarios han investigado parece que dice la verdad así que lo siento pero ya podéis ir quitándoos el gorro de aluminio.

» autor: --27313--

#74 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 21:50:34 +0000

#72 Como mínimo te están geolocalizando.

» autor: --505393--

#73 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--514899-- — Fri, 10 Jun 2016 21:50:29 +0000

#5 si, la telemetría se puede desactivar así que ese triger no haría nada

» autor: --514899--

#72 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--514899-- — Fri, 10 Jun 2016 21:49:06 +0000

#39 los trigers no hacen nada. Son avisos de que ha ocurrido algo. Es decisión del programa que hacer con ellos

» autor: --514899--

#71 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ezain123 — Fri, 10 Jun 2016 21:46:02 +0000

Solución: no usar Windows.

» autor: ezain123

#70 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--514899-- — Fri, 10 Jun 2016 21:40:36 +0000

#37 pues yo lo que veo es un triger a la telemetría, si tienes desactivada la telemetría en windows no debería enviarse nada.E n el windows se que se ejecute se entiende no donde se compile. Así que los SO sobre los que corren esas aplicaciones críticas deberían estar bien configurados. La opción para desactivar esto no está escondida y te pregunta al instalar windows

» autor: --514899--

#69 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

jefe_afogutu — Fri, 10 Jun 2016 21:10:17 +0000

Que chachiguay es el nuevo Microsoft.....en fin.

» autor: jefe_afogutu

#68 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

vicvic — Fri, 10 Jun 2016 20:25:25 +0000

#61 Los programadores de Windows también hacemos utilidades que devuelven códigos de retorno!

» autor: vicvic

#67 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--503250-- — Fri, 10 Jun 2016 19:52:19 +0000

#64 Tengo el modem que echa humo

» autor: --503250--

#66 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ricdelcagar — Fri, 10 Jun 2016 19:51:36 +0000

#39 y código que yo no he pedido

» autor: ricdelcagar

#65 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ricdelcagar — Fri, 10 Jun 2016 19:46:37 +0000

#6 o puede que cuando compilo código no me mola que le añadan instrucciones de más

» autor: ricdelcagar

#64 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ricdelcagar — Fri, 10 Jun 2016 19:44:12 +0000

#62 las creemos. Wireshark.

» autor: ricdelcagar

#63 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--193560-- — Fri, 10 Jun 2016 19:41:23 +0000

#24 El finally en C++ no hace falta porque todos los recursos se gestionan igual; usando RAII. En c#, java y python hace falta el finally (o using o with) porque el lenguaje solo gestiona la memoria, pero otros recursos como ficheros o mutex no.
Así que aunque a ti te parezca un inconveniente la falta fe finally, realmente es una feature.

» autor: --193560--

#62 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--503250-- — Fri, 10 Jun 2016 19:34:16 +0000

#2 #3 y el svchost.exe de windows hace llamadas por https a 390438408 servidores de Micro$oft, y el proceso system por DCOM, y el services.exe, hasta el explorer.exe hace llamadas de vez en cuando. Con el Outpost firewall se ven cosas que no creeriais.

» autor: --503250--

#61 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--198199-- — Fri, 10 Jun 2016 19:30:33 +0000

#60 Cierto. Cuando alguien escribe "void main" se ve a la legua que aprendió en MS-DOS/Windows, mientras que cuando ves "int main" no hay duda de que viene del mundo unix.

» autor: --198199--

#60 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--88270-- — Fri, 10 Jun 2016 19:24:07 +0000

#57 Los escriben void main() es porque no saben como el sistema operativo ejecuta los programas.
Si alguien hace un script o un bash, espera que el ejecutable devuelva un zero 0 un código de error.

» autor: --88270--

#59 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Aokromes — Fri, 10 Jun 2016 19:22:41 +0000

#11 #23 GCC es LENTO, LENTISIMO en comparacion de Clang, por desgracia, si actualizas a un sistema operativo que incluya GCC 5 olvidate de usar Clang hasta que lo arreglen.

» autor: Aokromes

#58 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Pakitopena — Fri, 10 Jun 2016 19:17:51 +0000

Menos mal que ha salido esta noticia porque me importa 3 cojones

» autor: Pakitopena

#57 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--151960-- — Fri, 10 Jun 2016 19:15:44 +0000

[Usuario deshabilitado]

» autor: --151960--

#56 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--174-- — Fri, 10 Jun 2016 19:13:25 +0000

#10: Tienes razón de rebote:
www.reddit.com/r/cpp/comments/4ibauu/visual_studio_adding_telemetry_fu

» autor: --174--

#55 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

parrita710 — Fri, 10 Jun 2016 19:13:02 +0000

#27

Do {
fap(hentai);
}while(vidaVacia)

» autor: parrita710

#54 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--111128-- — Fri, 10 Jun 2016 19:05:02 +0000

¿Y qué coño es eso del telemetry?

» autor: --111128--

#53 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--450592-- — Fri, 10 Jun 2016 18:56:06 +0000

#46 Ya verás que risa vuando te leas la noticia.

» autor: --450592--

#52 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

difusion — Fri, 10 Jun 2016 18:55:32 +0000

» autor: difusion

#51 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--506045-- — Fri, 10 Jun 2016 18:51:16 +0000

#50 añado he llevado a cabo la prueba en Linux, compilando estáticamente un binario C++ que solo hace un "return 0", igual que el de la noticia.

Mi binario llama a todas estas funciones del sistema:
0000000000405ed0 T abort
00000000006b62a0 B __abort_msg
0000000000457220 W access
0000000000457220 T __access
00000000004362a0 t add_alias2.isra.2.part.3
0000000000485340 t add_fdes
0000000000435f70 t add_module.isra.1
0000000000457980 t add_name_to_object.isra.3
00000000004594d0 t add_path.9908.isra.2.constprop.8
00000000006b5cc8 d adds.8399
000000000043f520 T __add_to_environ
000000000045f950 t add_to_global
0000000000407a00 t adjust_wide_data
00000000006b6760 V __after_morecore_hook
00000000004046d0 t alias_compare
00000000004122c0 W aligned_alloc
00000000006b6790 b aligned_heap_area
000000000045f010 t allocate_dtv
00000000004568d0 T __alloc_dir
000000000048db60 r archfname
00000000006b7220 b archive_stat
00000000006b7200 b archloaded
00000000006b72c8 b archmapped
0000000000411500 t arena_get2.isra.3
0000000000411890 t arena_get_retry
00000000006b67e8 b arena_mem
00000000004876a0 t arena_thread_freeres
00000000004533a0 T __argz_add_sep
00000000004533a0 W argz_add_sep
000000000041fd60 T __argz_count
000000000041fd60 W argz_count
00000000004532b0 T __argz_create_sep
00000000004532b0 W argz_create_sep
000000000041fdb0 T __argz_stringify
000000000041fdb0 W argz_stringify
0000000000407300 W asprintf
0000000000407300 T __asprintf
0000000000407300 T ___asprintf
00000000004017e0 T __assert_fail
00000000004016a0 T __assert_fail_base
00000000006b67a0 b atfork_mem
00000000006b6798 b atfork_recursive_cntr
0000000000432d70 W backtrace
0000000000432d70 T __backtrace
0000000000400330 t backtrace_and_maps
0000000000432ce0 t backtrace_helper
0000000000432dd0 T __backtrace_symbols_fd
0000000000432dd0 W backtrace_symbols_fd
0000000000485be0 t base_from_cb_data.isra.4
0000000000484e60 t base_from_object.isra.3
00000000004865d0 t base_of_encoded_value
0000000000418da0 i bcmp
000000000048a0f0 r blanks
000000000049b580 r blanks
0000000000457310 W brk
0000000000457310 T __brk
00000000006b5cd0 B __bss_start
0000000000453770 W btowc
0000000000453770 T __btowc
00000000006b7f00 b buf
0000000000445730 t buffered_vfprintf
000000000044f3c0 t buffered_vfprintf
0000000000486ce0 t buffer_free
000000000048c160 r builtin_aliases
00000000006b5880 d builtin_modules
00000000004193d0 W bzero
00000000004193d0 T __bzero
00000000004538f0 W c32rtomb
00000000006b7440 b cache
00000000006b6810 b cached_result.10238
00000000006b7180 b cache_malloced
00000000006b7438 b cache_new
0000000000459db0 t cache_rpath.part.7
00000000006b7430 b cachesize
00000000006b7188 b cache_size
0000000000430280 T __cache_sysconf
00000000004818a0 t call_dl_lookup
000000000046f9f0 t call_init.part.0
00000000004122d0 W calloc
00000000004122d0 T __calloc
w __call_tls_dtors
00000000006b4120 d capstr
0000000000411fb0 W cfree
0000000000411fb0 T __cfree
00000000006b48f0 d check_action
000000000046d0e0 t check_free.isra.0
000000000045ac80 t check_match.9694
0000000000401240 t check_one_fd
00000000004330b0 T __chk_fail
00000000004851c0 t classify_object_over_fdes
000000000043fae0 W clearenv
000000000043fae0 T __clearenv
0000000000431240 W close
0000000000431240 W __close
0000000000456a40 W closedir
0000000000456a40 T __closedir
0000000000431249 T __close_nocancel
000000000048cf40 r codeset_idx.9350
000000000049f980 r collseqmb
000000000049f560 r collseqwc
00000000006b5ce0 b completed.5861
00000000006b5840 d __compound_literal.0
00000000006b5830 d __compound_literal.1
00000000006b7160 b __compound_literal.2
00000000006b5300 d __compound_literal.3
0000000000454230 t compute_change
00000000004541f0 t compute_offset
00000000004552d0 t compute_tzname_max
000000000049e510 r conversion_rate
00000000004070b0 T __correctly_grouped_prefixmb
00000000006b7d40 B __cpu_features
0000000000418040 t critical_factorization
0000000000452b90 t critical_factorization
000000000043ec60 T __ctype_b_loc
000000000043ecc0 T __ctype_init
000000000043eca0 T __ctype_tolower_loc
000000000043ec80 T __ctype_toupper_loc
00000000006b7410 B __curbrk
000000000043ec40 T __current_locale_name
000000000049b8db r curwd.9602
0000000000406ba0 T __cxa_atexit
00000000006b74f8 b data
0000000000000048 b data.9062
00000000006b41c0 D __data_start
00000000006b41c0 W data_start
00000000006b7328 V daylight
00000000006b7328 B __daylight
0000000000401820 W dcgettext
0000000000401820 T __dcgettext
00000000004025a0 T __dcigettext
00000000006b6708 b dealloc_buffers
0000000000409fa0 t decide_maybe_mmap
0000000000414020 T __default_morecore
000000000049c460 r default_tzdir.5863
00000000004863a0 T __deregister_frame
0000000000486390 T __deregister_frame_info
0000000000486270 T __deregister_frame_info_bases
0000000000400ea0 t deregister_tm_clones
0000000000434eb0 t derivation_compare
0000000000435f10 t detect_conflict
00000000006b6788 b disallow_malloc_check
000000000046d270 T __dladdr
0000000000433bc0 T _dl_addr
000000000046d280 T __dladdr1
0000000000433e90 T _dl_addr_inside_object
000000000045c300 T _dl_add_to_namespace_list
000000000045f5e0 T _dl_add_to_slotinfo
00000000006b7d10 B _dl_all_dirs
000000000045c760 T _dl_allocate_static_tls
000000000045f4a0 T _dl_allocate_tls
000000000045f2a0 T _dl_allocate_tls_init
000000000045f160 T _dl_allocate_tls_storage
00000000006b40f0 D _dl_argv
0000000000433100 T _dl_aux_init
00000000006b7c98 B _dl_auxv
00000000006b7c90 B _dl_bind_not
000000000046e390 t _dl_build_local_scope
0000000000461c00 T _dl_cache_libcmp
000000000046f9e0 T _dl_call_pltexit
000000000045e5c0 T _dl_catch_error
00000000004709f0 T _dl_check_all_versions
0000000000470580 T _dl_check_map_versions
00000000006b7cd8 B _dl_clktck
0000000000478ec0 T __dlclose
00000000004615b0 T _dl_close
0000000000478eb0 t dlclose_doit
00000000006b7428 b dl_close_state.10478
0000000000460940 T _dl_close_worker
00000000006b52d8 D _dl_correct_cache_id
00000000006b7c88 B _dl_cpuclock_offset
000000000045f4e0 T _dl_deallocate_tls
00000000006b52dc D _dl_debug_fd
000000000045e6f0 T _dl_debug_initialize
00000000006b7c70 B _dl_debug_mask
000000000045ed30 T _dl_debug_printf
000000000045ede0 T _dl_debug_printf_c
000000000045e6e0 T _dl_debug_state
000000000045e760 t _dl_debug_vdprintf
0000000000433f40 T _dl_discover_osversion
000000000045ee90 T _dl_dprintf
00000000004595a0 T _dl_dst_count
0000000000459640 T _dl_dst_substitute
00000000006b7cdc B _dl_dynamic_weak
000000000046cf30 T __dlerror
00000000006b5c48 D _dl_error_catch_tsd
000000000046d140 T _dlerror_run
0000000000462300 t dlerror_run
00000000006b5c60 d _dlfcn_hooks
000000000045fb80 T _dl_find_dso_for_object
000000000046feb0 T _dl_fini
000000000046f610 T _dl_fixup
00000000006b52d4 D _dl_fpu_control
000000000045f6c0 T _dl_get_origin
000000000045f140 T _dl_get_tls_static_info
000000000045efa0 T _dl_higher_prime_number
00000000006b7158 B _dl_hwcap
00000000006b7150 B _dl_hwcap2
00000000006b7148 B _dl_hwcap_mask
000000000045dc50 T _dl_important_hwcaps
000000000046d380 T __dlinfo
000000000046d2b0 t dlinfo_doit
00000000006b7cb8 B _dl_inhibit_cache
00000000006b7d20 B _dl_inhibit_rpath
000000000046fb00 T _dl_init
00000000006b7ce8 B _dl_init_all_dirs
00000000006b7d08 B _dl_initfirst
0000000000462570 T _dl_initial_error_catch_tsd
00000000006b52f0 D _dl_initial_searchlist
0000000000459f60 T _dl_init_paths
00000000006b52e8 D _dl_init_static_tls
0000000000486a00 T __dl_iterate_phdr
0000000000486a00 W dl_iterate_phdr
00000000006b7ca8 B _dl_lazy
00000000006b5308 D _dl_load_adds
0000000000461ce0 T _dl_load_cache_lookup
00000000006b52a0 D _dl_load_lock
00000000006b5260 D _dl_load_write_lock
000000000045b6c0 T _dl_lookup_symbol_x
00000000006b53c0 d _dl_main_map
000000000045f8f0 T _dl_make_stack_executable
00000000006b52c8 D _dl_make_stack_executable_hook
000000000045a210 T _dl_map_object
000000000046e450 T _dl_map_object_deps
0000000000457af0 t _dl_map_object_from_fd
00000000004711c0 T _dl_mcount
0000000000462270 T _dl_mcount_wrapper
0000000000462280 T _dl_mcount_wrapper_check
000000000046d430 T __dlmopen
000000000046d3c0 t dlmopen_doit
000000000045ef30 T _dl_name_match_p
000000000045c3a0 T _dl_new_object
000000000045f060 T _dl_next_tls_modid
00000000006b5310 D _dl_nns
0000000000433310 T _dl_non_dynamic_init
000000000045c790 T _dl_nothread_init_static_tls
00000000006b5320 D _dl_ns
0000000000478e60 T __dlopen
000000000045fc10 T _dl_open
0000000000478de0 t dlopen_doit
00000000006b5c30 d _dl_open_hook
000000000045fff0 t dl_open_worker
00000000006b7cd0 B _dl_origin_path
00000000006b7d18 B _dl_osversion
000000000049da37 r _dl_out_of_memory
00000000006b52e0 D _dl_pagesize
00000000006b7cc0 B _dl_phdr
00000000006b7cf8 B _dl_phnum
00000000006b7ca0 B _dl_platform
00000000006b7c68 B _dl_platformlen
00000000006b7c80 B _dl_profile
000000000046f7d0 T _dl_profile_fixup
00000000006b7d00 B _dl_profile_map
00000000006b7c60 B _dl_profile_output
000000000045c810 T _dl_protect_relro
00000000006b40e0 D _dl_random
000000000045e680 T _dl_receive_error
000000000045c950 T _dl_relocate_object
000000000045c870 T _dl_reloc_bad_type
000000000045aa80 T _dl_rtld_di_serinfo
w _dl_rtld_map
00000000004616a0 T _dl_runtime_profile
0000000000461630 T _dl_runtime_resolve
000000000045f830 T _dl_scope_free
00000000006b7cc8 B _dl_scope_free_list
000000000045c250 T _dl_setup_hash
000000000045feb0 T _dl_show_scope
000000000045e540 T _dl_signal_cerror
000000000045e3d0 T _dl_signal_error
000000000046fc20 T _dl_sort_fini
00000000006b52d0 D _dl_stack_flags
00000000004340e0 T _dl_start
w _dl_starting_up
0000000000470a60 T _dl_start_profile
00000000006b7820 B _dl_static_dtv
0000000000478f00 T __dlsym
0000000000481c40 T _dl_sym
0000000000478ee0 t dlsym_doit
000000000045eca0 T _dl_sysdep_read_whole_file
00000000006b7ce0 B _dl_sysinfo_dso
00000000006b7cb0 B _dl_sysinfo_map
0000000000462800 T _dl_tlsdesc_resolve_hold
0000000000462710 T _dl_tlsdesc_resolve_hold_fixup
0000000000462790 T _dl_tlsdesc_resolve_rela
0000000000462580 T _dl_tlsdesc_resolve_rela_fixup
0000000000462770 T _dl_t

» autor: --506045--

#50 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--506045-- — Fri, 10 Jun 2016 18:48:04 +0000

Me da la sensación de que esto es una paranoia de alguien.

Si Windows quiere controlar cualquier cosa de las aplicaciones que ejecutas, no necesita en absoluto meter nada dentro de tu código. SI quiere disparar triggers de telemetría cada vez que lanzas una aplicacion, lo tiene tan fácil como meterlo en el loader de ejecutables. Si quiere analizar el comportamiento de tu aplicacion, lo puede hacer desde su API o desde el kernel. Hacerlo mediante la inyección de código me parece absurdo.

Igual de absurdo me parece que alguien piense que son tan tontos de inyectar una llamada API en los exes, esperando que nadie nunca se diera cuenta, cuando en el mundo Windows es el que tiene la mayor comunidad de ingeniería inversa con diferencia, cuando hay cientos de empresas que se pasan el día analizando binarios. Es ridículo.

En realidad, aunque tu programa solo sea un "return 0", ya no estamos en MS-DOS, y hace falta toda una capa de software que se ejecute antes de tu "main" (y otra después). Esto es así desde hace décadas y sucede en todos los sistemas operativos.

Me da que la capa que lleva el runtime de Windows 10 debe llamar a esta función como llama a otros cientos, a alguien no le ha gustado el nombre y ha hecho saltar la liebre, nada más

» autor: --506045--

#49 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--40836-- — Fri, 10 Jun 2016 18:46:51 +0000

#23 Gracias por el soplo. No tenía ni idea de la existencia de algo como clang.

» autor: --40836--

#48 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Nova6K0 — Fri, 10 Jun 2016 18:46:05 +0000

#10 Cualquier conexión, digamos innecesaria a Internet, especialmente si no está cifrada (y muchos de estos sistemas de telemetría no lo están al no considerarse datos personales, craso error) es propensa a un ataque Man In The Middle.

La conexión más inocente, no cifrada, puede provocar un enorme problema de seguridad. Si hablamos a nivel de usuario sería grave, pero a nivel de empresa podría ser catastrófico.

Salu2

» autor: Nova6K0

#47 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

frankiegth — Fri, 10 Jun 2016 18:09:31 +0000

Para #6. '...o puede ser una aplicación de hospital manejando datos confidenciales...'

O puede ser una máquina de radioterapia o un marcapasos. No se puede confiar en los productos Microsoft. Lo siento por ellos.

» autor: frankiegth

#46 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Pepintre — Fri, 10 Jun 2016 18:07:39 +0000

Verás que risa cuando os entereís que eso solo lo hace en la versión de debug con el debugger atachado

» autor: Pepintre

#45 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

barni — Fri, 10 Jun 2016 18:06:32 +0000

Yo a veces flipo con la conspiranoia del Meneante promedio, que elige indignarse primero y ya, si eso, googlear despues.

Esta "telemetría" lo único que hace es generar eventos ETW (Event Tracing for Windows). No está enviando ninguna información a Microsoft. Los datos sólo los puede ver Microsoft si el usuario les envía un .pdb al intentar solucionar un problema de compilación/debugging.

Que si, que está mal que lo hayan incluido, pero de ahí a pensar que Microsoft quiere robaros datos insertando llamadas en ejecutables cuando ya estáis ejecutando su sistema operativo es un poco tirado de los pelos.

» autor: barni

#44 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--507156-- — Fri, 10 Jun 2016 18:06:32 +0000

Con esto y con las actualizaciones por cojones del W10, éste va a ser el año de Moco$oft en tu escritorio... hasta que te pases a un sistema operativo a base de Software Libre

» autor: --507156--

#43 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Pepintre — Fri, 10 Jun 2016 18:06:25 +0000

#7 todo suposiciones incluso una cita. Increible tu comentario.

» autor: Pepintre

#42 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Ovlak — Fri, 10 Jun 2016 17:56:28 +0000

#36 Si lo hace el compilador de C++ que genera directamente código máquina, ten por seguro que lo hacen los lenguajes .net que generan código cil. Seguramente en ese caso ni sea necesario inyectar el backdoor en tiempo de compilación, sino que esté implementado en el runtime.

» autor: Ovlak

#41 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

salva6 — Fri, 10 Jun 2016 17:42:09 +0000

#10 Hola. Pasaba por aquí para decirte que las herramientas de desarrollo son de pago y cuyo control deberían estar bajo el control exclusivo del usuario que ha pagado por ellas. Además de que espiar el software que desarrollan otros podría ser considerado como delito de espionaje industrial.

» autor: salva6

#40 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--481179-- — Fri, 10 Jun 2016 17:41:49 +0000

#12 Con permiso:

"Guillotina ~~electoral~~ para los _ responsables de los _ partidos que han hundido la economía y han podrido la democracia"

» autor: --481179--

#39 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 17:40:32 +0000

#25 Da igual lo que haga: Es un riesgo de seguridad.

» autor: --505393--

#38 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 17:39:22 +0000

#12 No le voto mil veces positivo porque no puedo.

» autor: --505393--

#37 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 17:38:27 +0000

#16 No solo eso, sino que si además, es una aplicación "critica": HFT, temas sanitarios, militares, control industrial.
Puede ser un agujerito de seguridad gordo (localización).

» autor: --505393--

#36 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--27313-- — Fri, 10 Jun 2016 17:37:07 +0000

Y en el de c#? Porque igual me tengo que cagar en sus putas madres...

» autor: --27313--

#35 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 17:37:00 +0000

#10 Perdone por el negativo: Se me fue el dedo.
Luego le compenso.

Quería decir: ¿Por qué tiene un software que yo diseño y luego instalo en un cliente que mandar datos para mejorar "nada"?

Yo no he pedido eso.

» autor: --505393--

#34 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--505393-- — Fri, 10 Jun 2016 17:34:03 +0000

#3 Para todo lo demás: GCC

» autor: --505393--

#33 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

cros — Fri, 10 Jun 2016 17:30:43 +0000

#12 exacto!!!! Ni más ni menos.

» autor: cros

#32 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

cros — Fri, 10 Jun 2016 17:29:47 +0000

#17 esto es el ding de la noticia.
Ya que lo hacen lo mínimo es decirlo, así podemos elegir, luego que si conspiranoias y rollos, pero se lo ganan a pulso.

» autor: cros

#31 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--450592-- — Fri, 10 Jun 2016 17:27:36 +0000

#17 Un compilador te debe dar el binario correspondiente a tu código fuente y punto.

Menuda mierda de compilador.

» autor: --450592--

#30 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

xenko — Fri, 10 Jun 2016 17:25:08 +0000

#20 ¿Que policía, la de Estados Unidos a la que microsoft le ofrece backdoors a la mayoría de ordenadores mundo?

» autor: xenko

#29 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--280860-- — Fri, 10 Jun 2016 17:23:57 +0000

No se pero me da que el problema sera en 10 años o mas que los programadores no son seres que usan las ultimas versiones.
Firefox saco el multicore/multhread hace dos días coño que los quad cores existen desde el 2008.

» autor: --280860--

#28 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

rellos — Fri, 10 Jun 2016 17:19:58 +0000

www.win.tue.nl/~aeb/linux/hh/thompson/trust.html

» autor: rellos

#27 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

woopi — Fri, 10 Jun 2016 17:18:27 +0000

#21 #24 while (!empty) {
fap;
}

» autor: woopi

#26 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

demostenes — Fri, 10 Jun 2016 17:18:20 +0000

Digo yo de joderles la telemetría esa mediante un DDOS lanzando 100000 ejecutables "Hello World!" a la vez

» autor: demostenes

#25 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Bragi — Fri, 10 Jun 2016 17:18:15 +0000

No soy fan de microsoft pero la noticia no aclara que hace ese trigger. Si envia informacion vale seria un escandalo, pero si es informacion que envia al propio SO con objetivos de mejorar recuros segun lo que necesite el programa y el uso que da el usuario lo que veo es integracion del SO con su propio entorno de desarrollo.

» autor: Bragi

#24 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

grails — Fri, 10 Jun 2016 17:13:39 +0000

#21 Si fuese JAVA te hubieras quedado a gusto liberando recursos: try { sex }catch(Exception e){ zas } finally { pajilla }

Pero como es C++ te jodes y bailas... OK, dejo Meneame por hoy

» autor: grails

#23 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Blaxter — Fri, 10 Jun 2016 17:12:46 +0000

#11 Usa clang y nunca volverás atrás

» autor: Blaxter

#22 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--453740-- — Fri, 10 Jun 2016 17:09:58 +0000

A pesar del software libre y su crecimiento, cada vez somos menos dueños de nuestros datos.
Y la IoT y la F4.0 solo van a hacer que haya un crecimiento exponencial de este hecho.

Trabajo en industria, y por ejemplo tenemos medidor de consumo eléctrico de schneider. TODO lo guardan en la nube... Imaginad lo valiosísimo que seria para la competencia conocer el consumo eléctrico de un rival.

PD: Y casi todas las ofertas en este campo piden .net... Nosotros programamos en .net con VS2013

» autor: --453740--

#21 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

asterissco — Fri, 10 Jun 2016 17:08:50 +0000

#14 con erótico resultado try { sex }catch(e){ zas }

» autor: asterissco

#20 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Veelicus — Fri, 10 Jun 2016 17:06:07 +0000

Increible que este hecho no haga que la policia asalte las oficinas de Microsoft para investigar este hecho, esto es un delito muy grave.

» autor: Veelicus

#19 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

David_VG — Fri, 10 Jun 2016 17:04:50 +0000

#1 Ahora ese main(){return 0;} será más seguro

» autor: David_VG

#18 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Trigonometrico — Fri, 10 Jun 2016 17:01:27 +0000

#10 Venga ya tío, ¿me garantizas que las llamadas no incluyen información que pueda identificar a usuarios?

» autor: Trigonometrico

#17 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--32547-- — Fri, 10 Jun 2016 17:01:18 +0000

#10 Un compilador te debe dar el binario correspondiente a tu código fuente y punto.

Y si tiene features de estas, por lo menos que se sepa y estén documentadas, no a escondidas. Porque parece que esto era sin que los usuarios lo supiesen. Así que de "conspiranoia", nada.

» autor: --32547--

#16 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Maegruin — Fri, 10 Jun 2016 16:59:41 +0000

#10 Vale pero eso debe venir desactivado de serie y activarlo o solicitar el permiso de forma explicita (no escondido en las 5000 lineas de la licencia de uso que debes aceptar al instalar).

Imagina que alguien compila algún programa comercial suyo usando este IDE y luego algún usuario de este programa se da cuenta y lo denuncia. El creador del programa se puede meter en algún problema legal al no haber añadido lo de la telemetría en sus condiciones de uso por no saberlo.

» autor: Maegruin

#15 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

EDD88 — Fri, 10 Jun 2016 16:52:00 +0000

#10 Pero si lo explicas así no venderías ni una noticia.

» autor: EDD88

#14 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Acido — Fri, 10 Jun 2016 16:50:27 +0000

#9 Por eso te gusta tanto programar, un mundo lleno de sorpresas.

» autor: Acido

#13 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ccguy — Fri, 10 Jun 2016 16:50:08 +0000

#10 Anda que votar negativo sin saber lo que es TELEmetría...

» autor: ccguy

#12 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

libres — Fri, 10 Jun 2016 16:42:28 +0000

Es gravísimo. Una prueba mas de que el software privativo puede hacer cosas a nuestras espaldas sin que lo sepamos.

Lo cual, unido a la avaricia sin límite de las megacorporaciones, que son auténticos psicópatas carentes de principios con tal de ganar mas dinero (véase el documental "La corporación. ¿Instituciones o psicópatas?"), nos debe llevar a rechazar el software privativo.

In free software we trust
(En el software libre confiamos)

_____
Guillotina electoral para los partidos que han hundido la economía y han podrido la democracia.

» autor: libres

#11 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--198199-- — Fri, 10 Jun 2016 16:16:09 +0000

Cada día me gusta más GCC

» autor: --198199--

#10 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

CrudaVerdad — Fri, 10 Jun 2016 16:12:38 +0000

En el peor de los casos son métricas de software para medidas de desempeño, memoria o consumo de ancho de banda. Me imagino que lo hacen para medir que instrucciones son las más usadas y así poder mejorarlas u optimizarlas. De allí a que Microsoft utiliza esto para espiar programas es síntoma claro de conspiranoia pura y dura. ¿Por qué? Porque es imposible para un software saber que hace otro software, un compilador solo ve ciclos, variables, clases, métodos, ... pero no tiene idea para que están.

» autor: CrudaVerdad

#9 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

asterissco — Fri, 10 Jun 2016 16:07:02 +0000

#5 todas mis aplicaciones se comportan de forma inesperada al ejecutarse

» autor: asterissco

#8 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

kiklox — Fri, 10 Jun 2016 16:05:33 +0000

Por eso es mejor los programas de código abierto, a mi windows ya me parece cada vez mas un recopilador de datos que un sistema operativo.

Mi ordenador es mio, el sistema que lleva tendría que ser mío y mas si pago una licencia, eso de que metan cosas para bien favorecer a ellos o a quien quieran es una practica que tendría que ser declarada ilegal.

Por eso la apuesta por el código abierto, tanto en software como en hardware no es una tontería, tenemos millones de dispositivos y no sabemos que hace su firmware, sobre todo con la domotica que cada vez es mas presente, ni nuestro coche llegamos a controlar, esto un día nos dará una sorpresa.

» autor: kiklox

#7 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

dotromas — Fri, 10 Jun 2016 15:46:36 +0000

Ya lo dice nuestro amigo Snowden: "Piensa mal y acertaras" (bueno no lo dice, pero seguro que lo piensa). Por eso hay que apostar por Software Libre y abierto, que si, que pueden tener también sus problemas de seguridad, pero la gente tarde o temprano LOS VE y se toman medidas.

» autor: dotromas

#6 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ccguy — Fri, 10 Jun 2016 15:38:47 +0000

#4 ¿quién lo hace, el usuario final, o como?

A mí que un programa mío del que yo genero el binario final usando un compilador legal como el que viene con VS pueda de forma alguna dar información a Microsoft me parece alucinante, por no decir otra cosa. Joder, que ese binario puede ser una gilipollez o puede ser una aplicación de hospital manejando datos confidenciales.

» autor: ccguy

#5 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

nodearth — Fri, 10 Jun 2016 15:27:47 +0000

#4 Nop. Un compilador deberia darte el mismo codigo a nivel maquina. El hecho de que metan telemetria (lo cual no me lo creo) es muy preocupante puesto que las aplicaciones que se generan se comportan de forma inesperada al ejecutarse.

» autor: nodearth

#4 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

--170126-- — Fri, 10 Jun 2016 15:10:35 +0000

[Usuario deshabilitado]

» autor: --170126--

#3 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

ccguy — Fri, 10 Jun 2016 15:09:42 +0000

#2 Esta de las gordas... pero vamos, me parece un escándalo de cojones, del nivel de meter basura en los instaladores en plan softonic.

» autor: ccguy

#2 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

Remenad0r — Fri, 10 Jun 2016 15:07:39 +0000

Joder, otra feature.

» autor: Remenad0r

#1 El compilador de C++ de Visual Studio 2015 mete llamadas a la telemetría de Microsoft de forma silenciosa

dphi0pn — Fri, 10 Jun 2016 15:06:39 +0000

Son espionajes sanos

» autor: dphi0pn